第一次提交

InterfaceAutoTest/.idea/.gitignore

+# 默认忽略的文件
+/shelf/
+/workspace.xml

InterfaceAutoTest/.idea/InterfaceAutoTest.iml

+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+  <component name="PyDocumentationSettings">
+    <option name="format" value="PLAIN" />
+    <option name="myDocStringFormat" value="Plain" />
+  </component>
+  <component name="TestRunnerService">
+    <option name="PROJECT_TEST_RUNNER" value="py.test" />
+  </component>
+</module>
\ No newline at end of file

InterfaceAutoTest/.idea/inspectionProfiles/profiles_settings.xml

+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>
\ No newline at end of file

InterfaceAutoTest/.idea/misc.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.12" project-jdk-type="Python SDK" />
+</project>
\ No newline at end of file

InterfaceAutoTest/.idea/modules.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/InterfaceAutoTest.iml" filepath="$PROJECT_DIR$/.idea/InterfaceAutoTest.iml" />
+    </modules>
+  </component>
+</project>
\ No newline at end of file

InterfaceAutoTest/__init__.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test60
+# FileName:      __init__.py
+# Author:       lao_zhao
+# Datetime:     2024/5/20 15:40
+# Description:
+# 
+# ---------------------------------------------------------------------------
+import functools
+import logging
+import os
+import time
+
+log_dir_path = os.path.join(os.path.join(os.path.dirname(__file__), "report"), "log")
+if not os.path.exists(log_dir_path):
+    # makedirs(c:\c\d\a)  os.mkdir
+    os.makedirs(log_dir_path)
+
+log_file_name = os.path.join(log_dir_path, time.strftime("%Y_%m_%d_%H_%M_%S") + ".log")
+
+
+def log():
+    # 创建logger对象
+    logger = logging.getLogger()
+    # 设置日志的级别
+    logger.level = logging.ERROR
+    # 设置日志文件
+    handler = logging.FileHandler(log_file_name, mode="a", encoding="utf-8")
+    # 设置日志的格式
+    formatter = logging.Formatter('%(asctime)s - %(levelname)s: %(message)s')
+    # 将格式添加到handler中
+    handler.setFormatter(formatter)
+    # 将handler添加到logger对象中
+    logger.addHandler(handler)
+    return logger
+
+
+log = log()
+
+
+def log_decorator(func_name):
+    @functools.wraps(func_name)
+    def inner(*args, **kwargs):
+        try:
+            # 写入info级别的日志
+            """
+            __init__(): 构造方法，初始化对象
+            __new__(): 为对象分配内存空间
+            __del__(): 析构方法，回收对象
+            __enter__()/__exit__(): 实现上下文管理器
+            
+            __mro__: 查看继承顺序
+            __file__: 获取文件的路径
+            __name__: 获取功能/类/方法/模块的名称
+            __iter__(): 创建迭代器
+            __next__(): 迭代器和生成器取值
+            
+            __code__: 获取功能的code属性
+                    func.__code__.co_filename: 获取func所在的py文件名称
+                    func.__code__.co_firstlineno： 获取func所在的py文件中行号
+            __doc__：获取功能的描述
+            """
+            log.info(f"执行的功能为：{func_name.__name__}, 功能的描述为：{func_name.__doc__}, 所在的文件为："
+                     f"{func_name.__code__.co_filename}, 所在行为:{func_name.__code__.co_firstlineno}")
+            # 执行功能
+            return func_name(*args, **kwargs)
+        except Exception as e:
+            # 如果发生错误，写入一个错误的日志
+            log.error(f"执行的功能为：{func_name.__name__}, 功能的描述为：{func_name.__doc__}, 所在的文件为："
+                     f"{func_name.__code__.co_filename}, 所在行为:{func_name.__code__.co_firstlineno}, 错误为:{e}")
+            raise e
+    return inner
+
+
+
+# 报告输出
+"""
+
+    pytest-html----> pip install pytest-html
+    生成报告的命名：
+        pytest 用例层目录名称 -vv --html=存放报告的路径/报告名称.html --self-contained-html
+            -vv: 终端执行显示详细结果
+            --html: 存放报告的路径/报告名称.html
+            --self-contained-html: 报告生成单独的html文件
+"""
+# allure
+"""
+    allure-pytest --- > pip install allure-pytest
+
+    第一步：生成测试结果的json文件：pytest 用例模块/包 --alluredir=存放json文件的路径 --clean-alluredir
+    第二步：
+        生成一个服务：allure serve 第一步存放json文件的路径
+        生成静态报告：allure generate 第一步存放json文件的路径 -o 存放报告的路径
+            打开allure的静态报告：allure open 存放报告的路径
+    
+"""
+"""
+    失败重跑插件：pytest-rerunfailures ---> pip install pytest-rerunfailures
+
+"""
\ No newline at end of file

InterfaceAutoTest/common/db.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test60
+# FileName:      db.py
+# Author:       lao_zhao
+# Datetime:     2024/5/20 14:08
+# Description:
+# 
+# ---------------------------------------------------------------------------
+import pymysql
+
+from InterfaceAutoTest import log_decorator
+from InterfaceAutoTest.common.read_ini import ReadIni
+from InterfaceAutoTest.data_config.settings import *
+
+
+class DB:
+    @log_decorator
+    def __init__(self):
+        """链接数据库，获取链接对象和游标对象"""
+        ini = ReadIni()
+        try:
+            self.conn = pymysql.connect(
+                host=ini.get_db_connect_message(HOST_KEY),
+                port=int(ini.get_db_connect_message(PORT_KEY)),
+                user=ini.get_db_connect_message(USERNAME_KEY),
+                password=ini.get_db_connect_message(PASSWORD_KEY),
+                database=ini.get_db_connect_message(DATABASE_KEY),
+                charset="utf8"
+            )
+            self.cursor = self.conn.cursor()
+        except Exception as e:
+            raise e
+
+    @log_decorator
+    def close(self):
+        """关闭吧数据库链接"""
+        self.cursor.close()
+        self.conn.close()
+
+    @log_decorator
+    def delete_func(self, sql):
+        """执行删除的sql语句"""
+        try:
+            self.cursor.execute(sql)
+            self.conn.commit()
+        except Exception as e:
+            raise e
+
+    @log_decorator
+    def select_func(self, sql):
+        """执行查询的sql语句，并返回查询结果"""
+        try:
+          self.cursor.execute(sql)
+        except Exception as e:
+            raise e
+        else:
+            result_select = self.cursor.fetchall()
+            if result_select:
+                return result_select[0][0]
+
+
+if __name__ == '__main__':
+    db = DB()

InterfaceAutoTest/common/read_excel.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test60
+# FileName:      read_excel.py
+# Author:       lao_zhao
+# Datetime:     2024/5/20 14:15
+# Description:
+# 
+# ---------------------------------------------------------------------------
+import openpyxl
+
+from InterfaceAutoTest import log_decorator
+from InterfaceAutoTest.common.read_ini import ReadIni
+from InterfaceAutoTest.common.read_json import read_json
+from InterfaceAutoTest.data_config.settings import *
+
+
+class ReadExcel:
+    @log_decorator
+    def __init__(self, username="demo", table_name="BPM"):
+        """获取所有json文件的路径，再读取json文件，再获取excel的路径和工作表名称，加载工作簿，获取工作表"""
+        self.ini = ReadIni()
+
+        case_data_path = self.ini.get_file_path(CASE_KEY, username)
+        expect_data_path = self.ini.get_file_path(EXPECT_KEY, username)
+        sql_data_path = self.ini.get_file_path(SQL_KEY, username)
+
+        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)
+
+        excel_path = self.ini.get_file_path(EXCEL_KEY, username)
+        # table_name = self.ini.get_table_name("table_name")
+        try:
+            wb = openpyxl.load_workbook(excel_path)
+            self.ws = wb[table_name]
+        except Exception as e:
+            raise e
+
+    @log_decorator
+    def __get_cell_value(self, column: str, row: int) -> str:
+        """获取指定单元格数据"""
+        try:
+            value = self.ws[column+str(row)].value
+        except Exception as e:
+            raise e
+        else:
+            if value is None:
+                return None
+            elif value.strip():
+                return value.strip()
+
+    @log_decorator
+    def module_name(self, row):
+        """获取模块名称"""
+        return self.__get_cell_value(MODULE, row)
+
+    @log_decorator
+    def api_name(self, row):
+        """获取接口名称"""
+        return self.__get_cell_value(API, row)
+
+    @log_decorator
+    def case_req_method(self, row):
+        """获取请求方法"""
+        return self.__get_cell_value(METHOD, row)
+
+    @log_decorator
+    def case_req_url(self, row):
+        """获取请求url"""
+        value = self.__get_cell_value(URL, row)
+        if value:
+            return self.ini.get_host(BPM_KEY) + value
+
+    @log_decorator
+    def case_req_mime(self, row):
+        """获取请求的媒体类型"""
+        value = self.__get_cell_value(MIME, row)
+        if value:
+            return value.lower()
+
+    @log_decorator
+    def case_data(self, row):
+        """获取用例数据"""
+        case_data_key = self.__get_cell_value(CASE, row)
+        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]
+
+    @log_decorator
+    def expect_data(self, row):
+        """获取用例数据"""
+        expect_data_key = self.__get_cell_value(EXPECT, row)
+        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]
+
+    @log_decorator
+    def sql_data(self, row):
+        """获取用例数据"""
+        sql_data_key = self.__get_cell_value(SQL, row)
+        if sql_data_key:
+            module_name = self.module_name(row)
+            api_name = self.api_name(row)
+            return self.sql_data_dict[module_name][api_name][sql_data_key]
+
+    @log_decorator
+    def sql_type(self, row):
+        """获取sql语句类型"""
+        value = self.__get_cell_value(SQL_TYPE, row)
+        if value:
+            return value.lower()
+
+    @log_decorator
+    def update_key(self, row):
+        """获取更新的key"""
+        return self.__get_cell_value(UPDATE_KEY, row)
+
+    @log_decorator
+    def case_title(self, row):
+        """根据行号，获取用例的标题"""
+        return self.__get_cell_value(TITLE, row)
+
+    @log_decorator
+    def case_level(self, row):
+        """根据行，获取用例等级"""
+        return self.__get_cell_value(LEVEL, row)
+
+    @log_decorator
+    def get_data(self):
+        """获取excel中的数据存放在二维列表中"""
+        list_data = []
+        for row in range(2, self.ws.max_row+1):
+            method = self.case_req_method(row)
+            url = self.case_req_url(row)
+            mime = self.case_req_mime(row)
+            case_data = self.case_data(row)
+            expect_data = self.expect_data(row)
+            sql_data = self.sql_data(row)
+            sql_type = self.sql_type(row)
+            update_key = self.update_key(row)
+            # 用例模块，接口，标题，等级
+            module_name = self.module_name(row)
+            api_name = self.api_name(row)
+            case_title = self.case_title(row)
+            case_level = self.case_level(row)
+            if method and url:
+                list_data.append([module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key])
+        else:
+            return list_data
+
+
+if __name__ == '__main__':
+    excel = ReadExcel()
+    print(excel.get_data())
\ No newline at end of file

InterfaceAutoTest/common/read_ini.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test60
+# FileName:      read_ini.py
+# Author:       lao_zhao
+# Datetime:     2024/5/20 14:02
+# Description:
+# 
+# ---------------------------------------------------------------------------
+import configparser
+import os
+
+from InterfaceAutoTest import log_decorator
+from InterfaceAutoTest.data_config.settings import *
+
+
+class ReadIni:
+    @log_decorator
+    def __init__(self):
+        """获取ini文件的路径，再使用Configparser对象读取ini文件"""
+        self.data_config_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'data_config')
+        ini_path = os.path.join(self.data_config_path, 'config.ini')
+        self.conf = configparser.ConfigParser()
+        self.conf.read(ini_path, encoding="utf-8")
+
+    @log_decorator
+    def get_file_path(self, key, username="demo"):
+        """根据key获取file节点下文件的路径"""
+        try:
+            value = self.conf.get(FILE, key)
+        except Exception as e:
+            raise e
+        else:
+            username_dir = os.path.join(self.data_config_path, username)
+            return os.path.join(username_dir, value)
+
+    @log_decorator
+    def get_table_name(self, key):
+        """根据key获取工作表名称"""
+        try:
+            value = self.conf.get(WORKSHEET, key)
+        except Exception as e:
+            raise e
+        else:
+            return value
+
+    @log_decorator
+    def get_host(self, key):
+        """根据key获取域名"""
+        try:
+            value = self.conf.get(HOST, key)
+        except Exception as e:
+            raise e
+        else:
+            return value
+
+    @log_decorator
+    def get_db_connect_message(self, key):
+        """根据key获取数据库的链接信息"""
+        try:
+            value = self.conf.get(DB, key)
+        except Exception as e:
+            raise e
+        else:
+            return value
+
+
+if __name__ == '__main__':
+    ini = ReadIni()
+    print(ini.get_host("bpm"))
\ No newline at end of file

InterfaceAutoTest/common/read_json.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test60
+# FileName:      read_json.py
+# Author:       lao_zhao
+# Datetime:     2024/5/20 14:13
+# Description:
+# 
+# ---------------------------------------------------------------------------
+import json
+import os.path
+
+from InterfaceAutoTest import log_decorator
+
+
+@log_decorator
+def read_json(filename):
+    """读取json文件，将json文件的内容序列化为python对象"""
+    if os.path.isfile(filename) and filename.endswith(".json"):
+        try:
+            with open(filename, mode="r", encoding="utf-8") as f:
+                return json.load(f)
+        except Exception as e:
+            raise e
+    else:
+        raise FileNotFoundError("json文件的路径错误")
\ No newline at end of file

InterfaceAutoTest/data_config/config.ini

+# 配置数据配置层中文件的名称
+[file1]
+# 配置用例管理文件的名称
+excel=APIAutoTest.xlsx
+# 配置用例数据文件的名称
+case=case_data.json
+# 配置期望数据的文件
+expect=expect_data.json
+# sql语句的文件
+sql=sql_data.json
+
+[worksheet]
+table_name=BPM
+
+
+[host]
+# 配置测试系统的域名
+bpm=http://120.46.172.186:8080
+
+
+[db]
+# 配置测试系统的数据库的链接项
+host=120.46.172.186
+port=3306
+username=root
+password=root@2023
+database=eipsaas
\ No newline at end of file

InterfaceAutoTest/data_config/demo/case_data.json

+{
+    "认证接口":{
+        "登录系统":{
+            "LoginSuccess": {"username":"admin","password":"MTIzNDU2"},
+            "LoginErrorPasswordIsNone": {"username":"admin","password":""},
+            "LoginErrorPasswordIsLong":{"username":"admin","password":"MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2"},
+            "LoginErrorPasswordIsShort":{"username":"admin","password":"m"},
+            "LoginErrorPasswordIsSpecial":{"username":"admin","password":"☯㍿卍卐"},
+            "LoginErrorUsernameIsNone":{"username":"","password":"MTIzNDU2"},
+            "LoginErrorUsernameIsLong":{"username":"adminadminadminadmin","password":"MTIzNDU2"},
+            "LoginErrorUsernameIsShort":{"username":"a","password":"MTIzNDU2"},
+            "LoginErrorUsernameIsSpecial":{"username":"☯㍿卍卐","password":"MTIzNDU2"},
+            "LoginErrorUsernameIsErr":{"username":"admin123","password":"MTIzNDU2"}
+        }
+    },
+    "维度管理": {
+        "添加维度": {
+            "AddDemSuccess": {
+                "code": "api_auto_test_add_dem",
+                "description": "api_auto_test_add_dem",
+                "isDefault": 0,
+                "name": "api_auto_test_add_dem"
+            }
+        },
+        "根据维度编码删除维度": {
+            "DeleteDemSuccess": {"ids": "需要更新"}
+        }
+    },
+    "组织管理": {
+        "添加组织": {
+            "AddOrgSuccess": {
+                "code": "test_add_org",
+                "demId": "需要更新",
+                "exceedLimitNum": 0,
+                "grade": "",
+                "limitNum": 0,
+                "name": "测试添加的组织",
+                "nowNum": 0,
+                "orderNo": 0,
+                "parentId": "0"
+            }
+        },
+        "组织加入用户": {
+            "UserAddOrgSuccess": {"orgCode": "test_add_org", "accounts": "admin"}
+        },
+        "保存组织参数": {
+            "SaveParamSuccess": {
+                "query": {"orgCode": "test_add_org"},
+                "body": [{"alias":"sz","value":100},{"alias":"kc","value":"语文课"}]
+            }
+        },
+        "删除组织": {
+            "DeleteOrgSuccess": "test_add_org"
+        }
+    }
+}
\ No newline at end of file

InterfaceAutoTest/data_config/demo/expect_data.json

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

InterfaceAutoTest/data_config/demo/sql_data.json

+{
+  "维度管理": {
+    "添加维度": {
+      "AddDemSuccess": "delete FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";"
+    },
+    "根据维度编码删除维度": {
+      "DeleteDemSuccess": "select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";"
+    }
+  },
+  "组织管理": {
+        "添加组织": {
+            "AddOrgSuccess": {
+              "select": "select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";",
+              "delete": "DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";"
+            }
+        }
+    }
+}
\ No newline at end of file

InterfaceAutoTest/data_config/mirZhang/case_data.json

+{
+    "认证接口":{
+        "登录系统":{
+            "LoginSuccess": {"username":"admin","password":"MTIzNDU2"},
+            "LoginErrorPasswordIsNone": {"username":"admin","password":""},
+            "LoginErrorPasswordIsLong":{"username":"admin","password":"MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2"},
+            "LoginErrorPasswordIsShort":{"username":"admin","password":"m"},
+            "LoginErrorPasswordIsSpecial":{"username":"admin","password":"☯㍿卍卐"},
+            "LoginErrorUsernameIsNone":{"username":"","password":"MTIzNDU2"},
+            "LoginErrorUsernameIsLong":{"username":"adminadminadminadmin","password":"MTIzNDU2"},
+            "LoginErrorUsernameIsShort":{"username":"a","password":"MTIzNDU2"},
+            "LoginErrorUsernameIsSpecial":{"username":"☯㍿卍卐","password":"MTIzNDU2"},
+            "LoginErrorUsernameIsErr":{"username":"admin123","password":"MTIzNDU2"}
+        }
+    },
+    "维度管理": {
+        "添加维度": {
+            "AddDemSuccess": {
+                "code": "api_auto_test_add_dem",
+                "description": "api_auto_test_add_dem",
+                "isDefault": 0,
+                "name": "api_auto_test_add_dem"
+            }
+        },
+        "根据维度编码删除维度": {
+            "DeleteDemSuccess": {"ids": "需要更新"}
+        }
+    },
+    "组织管理": {
+        "添加组织": {
+            "AddOrgSuccess": {
+                "code": "test_add_org",
+                "demId": "需要更新",
+                "exceedLimitNum": 0,
+                "grade": "",
+                "limitNum": 0,
+                "name": "测试添加的组织",
+                "nowNum": 0,
+                "orderNo": 0,
+                "parentId": "0"
+            }
+        },
+        "组织加入用户": {
+            "UserAddOrgSuccess": {"orgCode": "test_add_org", "accounts": "admin"}
+        },
+        "保存组织参数": {
+            "SaveParamSuccess": {
+                "query": {"orgCode": "test_add_org"},
+                "body": [{"alias":"sz","value":100},{"alias":"kc","value":"语文课"}]
+            }
+        },
+        "删除组织": {
+            "DeleteOrgSuccess": "test_add_org"
+        }
+    }
+}
\ No newline at end of file

InterfaceAutoTest/data_config/mirZhang/expect_data.json

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

InterfaceAutoTest/data_config/mirZhang/sql_data.json

+{
+  "维度管理": {
+    "添加维度": {
+      "AddDemSuccess": "delete FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";"
+    },
+    "根据维度编码删除维度": {
+      "DeleteDemSuccess": "select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";"
+    }
+  },
+  "组织管理": {
+        "添加组织": {
+            "AddOrgSuccess": {
+              "select": "select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";",
+              "delete": "DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";"
+            }
+        }
+    }
+}
\ No newline at end of file

InterfaceAutoTest/data_config/settings.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test60
+# FileName:      settings.py
+# Author:       lao_zhao
+# Datetime:     2024/5/21 10:15
+# Description:
+# 
+# ---------------------------------------------------------------------------
+
+
+# excel的列号=======================================
+NUMBER = "A"
+MODULE = "B"
+API = "C"
+TITLE = "D"
+LEVEL = "E"
+METHOD = "F"
+URL = "G"
+MIME = "H"
+CASE = "I"
+EXPECT = "J"
+SQL = "K"
+SQL_TYPE = "L"
+UPDATE_KEY = "M"
+
+
+# ini文件中节点名称======================================
+FILE = "file1"
+WORKSHEET = "worksheet"
+HOST = "host"
+DB = "db"
+
+
+# ini文件中键名称======================================
+# file节点============================================
+EXCEL_KEY = "excel"
+CASE_KEY = "case"
+EXPECT_KEY = "expect"
+SQL_KEY = "sql"
+
+# worksheet节点============================================
+TABLE_NAME_KEY = "table_name"
+
+
+# host节点============================================
+BPM_KEY = "bpm"
+
+# db节点============================================
+HOST_KEY = "host"
+PORT_KEY = "port"
+USERNAME_KEY = "username"
+PASSWORD_KEY = "password"
+DATABASE_KEY = "database"
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/116a66ad8e750f6d.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803532844318720"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803541883043840"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803550955323392"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803560044380160"}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/195d3c3ed8fa0070.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'username': 'adminadminadminadmin', 'password': 'MTIzNDU2'}, 期望数据为:{'message': '账号或密码错误'}, 服务器返回的数据为：{"state":false,"message":"账号或密码错误","logId":"1792803332507582464"}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/1cc5cc26b0e6793e.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803436442435584"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803445468577792"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803454528274432"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803463587971072"}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/208c263728b0d9ca.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803532844318720"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803541883043840"}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/26ab91eb58d5437f.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'orgCode': 'test_add_org', 'accounts': 'admin'}, 期望数据为:{'state': True, 'message': '加入成功', 'value': ''}, 服务器返回的数据为：{"state":true,"message":"加入成功","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/27912ca823c311e6.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'username': 'admin', 'password': 'm'}, 期望数据为:{'message': '账号或密码错误'}, 服务器返回的数据为：{"state":false,"message":"账号或密码错误","logId":"1792803331177988096"}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/2a6299f399f58eb7.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/2ffbcb889e2046d8.txt

+断言

InterfaceAutoTest/report/allure/html/data/attachments/39baf5c12bf79df8.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTg5OTgsImlhdCI6MTcxNjI3MjU5OH0.4JgpWuf9sSQnYV9dPIhf0I76OkCqUlLws0abjIB0nEM_iXrT2qd79jiUvk3kiwUvDIw9aHYQdvVjAFq8AQLNCw","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDAsImlhdCI6MTcxNjI3MjYwMH0.atAGdmkk-bhC9iAhggDWp0VlgVLl39hN3_u2ytWqmjm1GWT-vhDYRgCax56GrBuR6EkPJEseXgX-S8EfzoWXhg","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDIsImlhdCI6MTcxNjI3MjYwMn0.2ULfoTRcxys6pnuEKjHxZH4GI20D2qBisJFYoBn2GdZLw23Xapl1u2ATzI1w5cFlBcJf3_bFyVN7eo7OfOOMUg","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDQsImlhdCI6MTcxNjI3MjYwNH0.TOXPdeAD96XQ_Maa-ITQDDQZTnKhlW09esTDC6-C8_Wux9HSk3bWURoOvhmcidK-lCj4Tvw1ZO0dYFWGR8-lsg","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDYsImlhdCI6MTcxNjI3MjYwNn0.W_ynWuu-79lzZS5ScuftmKzI8_B3z3llQ0gnSpahTsvIdUBKeaos4loXKk4DrzU4CGbchLTa5lK48yzcFXXQoA","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/3b913b49dc4f3472.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTg5OTgsImlhdCI6MTcxNjI3MjU5OH0.4JgpWuf9sSQnYV9dPIhf0I76OkCqUlLws0abjIB0nEM_iXrT2qd79jiUvk3kiwUvDIw9aHYQdvVjAFq8AQLNCw","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/3ee4fb5ea7f92b8a.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803532844318720"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803541883043840"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803550955323392"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803560044380160"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803569104076800"}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/436d5cd427874b03.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803436442435584"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803445468577792"}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/4a87a856d252348a.txt

+断言

InterfaceAutoTest/report/allure/html/data/attachments/4b82c6a38a94e361.txt

+断言

InterfaceAutoTest/report/allure/html/data/attachments/4c9392d6daa2384.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'username': 'admin', 'password': '☯㍿卍卐'}, 期望数据为:{'message': '账号或密码错误'}, 服务器返回的数据为：{"state":false,"message":"账号或密码错误","logId":"1792803331643555840"}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/538dd3c6269d607b.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'username': '', 'password': 'MTIzNDU2'}, 期望数据为:{'message': '账号或密码错误'}, 服务器返回的数据为：{"state":false,"message":"账号或密码错误","logId":"1792803332075569152"}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/5a84d42ab44260be.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'username': 'admin', 'password': 'MTIzNDU2'}, 期望数据为:{'username': '超级管理员', 'loginStatus': True, 'account': 'admin'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTg5OTcsImlhdCI6MTcxNjI3MjU5N30.sY4lvg3FdRhPw7aTY0jx3ZeN03MQbTx1bARhQIZP2H41KaUr83P2Q4MTt-AKuPxQxYsVlEOH9rPkM0X7HhxEJA","username":"超级管理员","account":"admin","userId":"1","expiration":86400,"loginStatus":true,"userAttrs":{"tenantId":"-1"}}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/5beb8dd75024124b.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'query': {'orgCode': 'test_add_org'}, 'body': [{'alias': 'sz', 'value': 100}, {'alias': 'kc', 'value': '语文课'}]}, 期望数据为:{'state': True, 'message': '保存组织参数成功！', 'value': ''}, 服务器返回的数据为：{"state":true,"message":"保存组织参数成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/6413450afbe297d.txt

+断言

InterfaceAutoTest/report/allure/html/data/attachments/6666807bee4dd972.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803532844318720"}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/68079d64d13b4b9b.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803436442435584"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803445468577792"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803454528274432"}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/69ecbaba4125d9c7.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/6b95a89eb4116b8d.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/6e082c14d64f516c.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/6ea91b34562fdff6.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803436442435584"}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/71a819440c253d52.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'username': 'admin', 'password': ''}, 期望数据为:{'message': '账号或密码错误'}, 服务器返回的数据为：{"state":false,"message":"账号或密码错误","logId":"1792803330313961472"}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/7201d70001e141e.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'orgCode': 'test_add_org', 'accounts': 'admin'}, 期望数据为:{'state': True, 'message': '加入成功', 'value': ''}, 服务器返回的数据为：{"state":true,"message":"加入成功","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/756ecf2b72d113b2.txt

+断言

InterfaceAutoTest/report/allure/html/data/attachments/7ca9dc953c624cc6.txt

+用例函数1

InterfaceAutoTest/report/allure/html/data/attachments/7cd371d730635a5c.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/7cf883af7fabeddf.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'username': '☯㍿卍卐', 'password': 'MTIzNDU2'}, 期望数据为:{'message': '账号或密码错误'}, 服务器返回的数据为：{"state":false,"message":"账号或密码错误","logId":"1792803333417746432"}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/85bb81ed805a1bc2.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTg5OTgsImlhdCI6MTcxNjI3MjU5OH0.4JgpWuf9sSQnYV9dPIhf0I76OkCqUlLws0abjIB0nEM_iXrT2qd79jiUvk3kiwUvDIw9aHYQdvVjAFq8AQLNCw","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDAsImlhdCI6MTcxNjI3MjYwMH0.atAGdmkk-bhC9iAhggDWp0VlgVLl39hN3_u2ytWqmjm1GWT-vhDYRgCax56GrBuR6EkPJEseXgX-S8EfzoWXhg","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDIsImlhdCI6MTcxNjI3MjYwMn0.2ULfoTRcxys6pnuEKjHxZH4GI20D2qBisJFYoBn2GdZLw23Xapl1u2ATzI1w5cFlBcJf3_bFyVN7eo7OfOOMUg","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDQsImlhdCI6MTcxNjI3MjYwNH0.TOXPdeAD96XQ_Maa-ITQDDQZTnKhlW09esTDC6-C8_Wux9HSk3bWURoOvhmcidK-lCj4Tvw1ZO0dYFWGR8-lsg","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDYsImlhdCI6MTcxNjI3MjYwNn0.W_ynWuu-79lzZS5ScuftmKzI8_B3z3llQ0gnSpahTsvIdUBKeaos4loXKk4DrzU4CGbchLTa5lK48yzcFXXQoA","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDgsImlhdCI6MTcxNjI3MjYwOH0.LsIqI6NBfMYmLfeFQHaiE3TLchmrNO9P3P92GkiuQQoiDTEXfelTGerbpaF-Qp4K4_45jG2cACLNB8dNwS0m-w","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/879a46074811af0.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803436442435584"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803445468577792"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803454528274432"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803463587971072"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803472635084800"}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/8883fd4feebc6905.txt

+断言

InterfaceAutoTest/report/allure/html/data/attachments/8a43ab00612fb800.txt

+断言

InterfaceAutoTest/report/allure/html/data/attachments/8b75f965076bf807.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTg5OTgsImlhdCI6MTcxNjI3MjU5OH0.4JgpWuf9sSQnYV9dPIhf0I76OkCqUlLws0abjIB0nEM_iXrT2qd79jiUvk3kiwUvDIw9aHYQdvVjAFq8AQLNCw","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDAsImlhdCI6MTcxNjI3MjYwMH0.atAGdmkk-bhC9iAhggDWp0VlgVLl39hN3_u2ytWqmjm1GWT-vhDYRgCax56GrBuR6EkPJEseXgX-S8EfzoWXhg","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDIsImlhdCI6MTcxNjI3MjYwMn0.2ULfoTRcxys6pnuEKjHxZH4GI20D2qBisJFYoBn2GdZLw23Xapl1u2ATzI1w5cFlBcJf3_bFyVN7eo7OfOOMUg","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDQsImlhdCI6MTcxNjI3MjYwNH0.TOXPdeAD96XQ_Maa-ITQDDQZTnKhlW09esTDC6-C8_Wux9HSk3bWURoOvhmcidK-lCj4Tvw1ZO0dYFWGR8-lsg","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/8c5282cbec7e86da.txt

+断言

InterfaceAutoTest/report/allure/html/data/attachments/8f0dd4d860439e9d.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为test_add_org, 期望数据为:{'state': True, 'message': '删除组织成功！', 'value': ''}, 服务器返回的数据为：{"state":true,"message":"删除组织成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/93c840dec4b9b526.txt

+断言成功

InterfaceAutoTest/report/allure/html/data/attachments/95802db4a485e5cb.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTg5OTgsImlhdCI6MTcxNjI3MjU5OH0.4JgpWuf9sSQnYV9dPIhf0I76OkCqUlLws0abjIB0nEM_iXrT2qd79jiUvk3kiwUvDIw9aHYQdvVjAFq8AQLNCw","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDAsImlhdCI6MTcxNjI3MjYwMH0.atAGdmkk-bhC9iAhggDWp0VlgVLl39hN3_u2ytWqmjm1GWT-vhDYRgCax56GrBuR6EkPJEseXgX-S8EfzoWXhg","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/9822ad938ab5e065.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'query': {'orgCode': 'test_add_org'}, 'body': [{'alias': 'sz', 'value': 100}, {'alias': 'kc', 'value': '语文课'}]}, 期望数据为:{'state': True, 'message': '保存组织参数成功！', 'value': ''}, 服务器返回的数据为：{"state":true,"message":"保存组织参数成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/987782255dd3f0f5.txt

+断言

InterfaceAutoTest/report/allure/html/data/attachments/a66f6f015a0908d7.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'username': 'a', 'password': 'MTIzNDU2'}, 期望数据为:{'message': '账号或密码错误'}, 服务器返回的数据为：{"state":false,"message":"账号或密码错误","logId":"1792803332960567296"}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/a6c92586b9cefbbf.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/a8ff188565383ebb.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/a9bcf4a95c5389c9.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'username': 'admin', 'password': 'MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2'}, 期望数据为:{'message': '账号或密码错误'}, 服务器返回的数据为：{"state":false,"message":"账号或密码错误","logId":"1792803330750169088"}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/aa23f63cb24a3b27.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803532844318720"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803541883043840"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803550955323392"}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/ac741aa1898e1262.txt

+断言

InterfaceAutoTest/report/allure/html/data/attachments/b398dd14596ef633.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/b40117ab71b81a91.txt

+断言

InterfaceAutoTest/report/allure/html/data/attachments/ba6929d93441163b.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'username': 'admin123', 'password': 'MTIzNDU2'}, 期望数据为:{'message': '账号或密码错误'}, 服务器返回的数据为：{"state":false,"message":"账号或密码错误","logId":"1792803333887508480"}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/bbc2176bbcbfcb7e.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'code': 'api_auto_test_add_dem', 'description': 'api_auto_test_add_dem', 'isDefault': 0, 'name': 'api_auto_test_add_dem'}, 期望数据为:{'message': '添加维度成功！'}, 服务器返回的数据为：{"state":true,"message":"添加维度成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/bbd501f9dbcd3dda.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/bd632cb85700b6eb.txt

+断言

InterfaceAutoTest/report/allure/html/data/attachments/c03a0df9281574b5.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/c3a3b7a3c91bcff7.txt

+断言

InterfaceAutoTest/report/allure/html/data/attachments/c40a6c404248f2af.txt

+断言

InterfaceAutoTest/report/allure/html/data/attachments/c49546fe18c84daf.txt

+断言

InterfaceAutoTest/report/allure/html/data/attachments/c8901e6970c427be.txt

+断言成功

InterfaceAutoTest/report/allure/html/data/attachments/cf084e108e2df99e.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/d58b94aaa68aa2dd.txt

+断言

InterfaceAutoTest/report/allure/html/data/attachments/daf1a95306848a3.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为test_add_org, 期望数据为:{'state': True, 'message': '删除组织成功！', 'value': ''}, 服务器返回的数据为：{"state":true,"message":"删除组织成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/dde9a1e6e87f25aa.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTg5OTgsImlhdCI6MTcxNjI3MjU5OH0.4JgpWuf9sSQnYV9dPIhf0I76OkCqUlLws0abjIB0nEM_iXrT2qd79jiUvk3kiwUvDIw9aHYQdvVjAFq8AQLNCw","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDAsImlhdCI6MTcxNjI3MjYwMH0.atAGdmkk-bhC9iAhggDWp0VlgVLl39hN3_u2ytWqmjm1GWT-vhDYRgCax56GrBuR6EkPJEseXgX-S8EfzoWXhg","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDIsImlhdCI6MTcxNjI3MjYwMn0.2ULfoTRcxys6pnuEKjHxZH4GI20D2qBisJFYoBn2GdZLw23Xapl1u2ATzI1w5cFlBcJf3_bFyVN7eo7OfOOMUg","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/de31b21afa53e092.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/e05bc2e897e525cd.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/e225611ab025f71d.txt

+断言

InterfaceAutoTest/report/allure/html/data/attachments/f01d7cb12097c711.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'code': 'api_auto_test_add_dem', 'description': 'api_auto_test_add_dem', 'isDefault': 0, 'name': 'api_auto_test_add_dem'}, 期望数据为:{'message': '添加维度成功！'}, 服务器返回的数据为：{"state":true,"message":"添加维度成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/f32a4201d93ebd55.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/attachments/f6d07ad08c02221c.txt

+断言

InterfaceAutoTest/report/allure/html/data/behaviors.csv

+"Epic","Feature","Story","FAILED","BROKEN","PASSED","SKIPPED","UNKNOWN"
+"BPM系统-demo","认证接口","登录系统","0","0","10","0","0"
+"BPM系统-demo","认证接口","刷新token","1","0","0","0","0"
+"BPM系统-demo","维度管理","根据维度编码删除维度","1","0","0","0","0"
+"BPM系统-demo","组织管理","删除组织","0","0","1","0","0"
+"BPM系统-老张","组织管理","删除组织","0","0","1","0","0"
+"BPM系统-老张","组织管理","保存组织参数","0","0","1","0","0"
+"BPM系统-老张","组织管理","组织加入用户","0","0","1","0","0"
+"BPM系统-demo","维度管理","添加维度","0","0","1","0","0"
+"BPM系统-demo","组织管理","添加组织","1","0","0","0","0"
+"BPM系统-demo","组织管理","组织加入用户","0","0","1","0","0"
+"BPM系统-demo","组织管理","保存组织参数","0","0","1","0","0"
+"BPM-场景测试","认证接口","登录系统","0","0","1","0","0"
+"BPM系统-老张","维度管理","添加维度","0","0","1","0","0"
+"BPM系统-老张","维度管理","根据维度编码删除维度","1","0","0","0","0"
+"BPM-场景测试","维度管理","添加维度","0","0","1","0","0"
+"BPM系统-老张","组织管理","添加组织","1","0","0","0","0"
+"BPM-场景测试","test","test","0","0","1","0","0"

InterfaceAutoTest/report/allure/html/data/behaviors.json

+{
+  "uid" : "b1a8273437954620fa374b796ffaacdd",
+  "name" : "behaviors",
+  "children" : [ {
+    "name" : "BPM系统-demo",
+    "children" : [ {
+      "name" : "认证接口",
+      "children" : [ {
+        "name" : "登录系统",
+        "children" : [ {
+          "name" : "正向用例-正确输入用户名和密码",
+          "uid" : "80142e22de024a60",
+          "parentUid" : "54068c4b34235e80b3707de86ff13e04",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272598748,
+            "stop" : 1716272598811,
+            "duration" : 63
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'登录系统'", "{'username': 'admin', 'password': 'MTIzNDU2'}", "'高'", "'正向用例-正确输入用户名和密码'", "{'username': '超级管理员', 'loginStatus': True, 'account': 'admin'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+        }, {
+          "name" : "反向用例-用户名正确,密码为空",
+          "uid" : "1bd3c031f056ab2e",
+          "parentUid" : "54068c4b34235e80b3707de86ff13e04",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272598829,
+            "stop" : 1716272598886,
+            "duration" : 57
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'登录系统'", "{'username': 'admin', 'password': ''}", "'中'", "'反向用例-用户名正确,密码为空'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+        }, {
+          "name" : "反向用例-用户名正确,密码过长",
+          "uid" : "c26c17d72f28aa7f",
+          "parentUid" : "54068c4b34235e80b3707de86ff13e04",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272598895,
+            "stop" : 1716272598989,
+            "duration" : 94
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'登录系统'", "{'username': 'admin', 'password': 'MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2'}", "'中'", "'反向用例-用户名正确,密码过长'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+        }, {
+          "name" : "反向用例-用户名正确,密码过短",
+          "uid" : "e425d3e0108cef57",
+          "parentUid" : "54068c4b34235e80b3707de86ff13e04",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272598998,
+            "stop" : 1716272599093,
+            "duration" : 95
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'登录系统'", "{'username': 'admin', 'password': 'm'}", "'中'", "'反向用例-用户名正确,密码过短'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+        }, {
+          "name" : "反向用例-用户名正确,密码为特殊字符",
+          "uid" : "d093b8587a3ab4f3",
+          "parentUid" : "54068c4b34235e80b3707de86ff13e04",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272599103,
+            "stop" : 1716272599203,
+            "duration" : 100
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'登录系统'", "{'username': 'admin', 'password': '☯㍿卍卐'}", "'中'", "'反向用例-用户名正确,密码为特殊字符'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+        }, {
+          "name" : "反向用例-密码正确,用户名为空",
+          "uid" : "5532c9175fb2354e",
+          "parentUid" : "54068c4b34235e80b3707de86ff13e04",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272599213,
+            "stop" : 1716272599306,
+            "duration" : 93
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'登录系统'", "{'username': '', 'password': 'MTIzNDU2'}", "'中'", "'反向用例-密码正确,用户名为空'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+        }, {
+          "name" : "反向用例-密码正确,用户名过长",
+          "uid" : "8142d41860b04b15",
+          "parentUid" : "54068c4b34235e80b3707de86ff13e04",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272599315,
+            "stop" : 1716272599407,
+            "duration" : 92
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'登录系统'", "{'username': 'adminadminadminadmin', 'password': 'MTIzNDU2'}", "'中'", "'反向用例-密码正确,用户名过长'", "{'message': '账号或密码错误'}", "'POST'", "'json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+        }, {
+          "name" : "反向用例-密码正确,用户名过短",
+          "uid" : "96596e0fab9d3415",
+          "parentUid" : "54068c4b34235e80b3707de86ff13e04",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272599418,
+            "stop" : 1716272599517,
+            "duration" : 99
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'登录系统'", "{'username': 'a', 'password': 'MTIzNDU2'}", "'中'", "'反向用例-密码正确,用户名过短'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+        }, {
+          "name" : "反向用例-密码正确,用户名为特殊字符",
+          "uid" : "5b0b595f880fe013",
+          "parentUid" : "54068c4b34235e80b3707de86ff13e04",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272599527,
+            "stop" : 1716272599627,
+            "duration" : 100
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'登录系统'", "{'username': '☯㍿卍卐', 'password': 'MTIzNDU2'}", "'中'", "'反向用例-密码正确,用户名为特殊字符'", "{'message': '账号或密码错误'}", "'POST'", "'json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+        }, {
+          "name" : "反向用例-密码正确,用户名错误",
+          "uid" : "a0b87df8f50dc316",
+          "parentUid" : "54068c4b34235e80b3707de86ff13e04",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272599640,
+            "stop" : 1716272599737,
+            "duration" : 97
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'登录系统'", "{'username': 'admin123', 'password': 'MTIzNDU2'}", "'中'", "'反向用例-密码正确,用户名错误'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+        } ],
+        "uid" : "54068c4b34235e80b3707de86ff13e04"
+      }, {
+        "name" : "刷新token",
+        "children" : [ {
+          "name" : "正向用例",
+          "uid" : "139913cc61e34bb9",
+          "parentUid" : "412797404a49368b01459232917764e5",
+          "status" : "failed",
+          "time" : {
+            "start" : 1716272610326,
+            "stop" : 1716272610382,
+            "duration" : 56
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'刷新token'", "None", "'中'", "'正向用例'", "{'message': '刷新token成功'}", "'GET'", "None", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/refresh'" ]
+        } ],
+        "uid" : "412797404a49368b01459232917764e5"
+      } ],
+      "uid" : "fee5f38f156c59a7229cd608f480f397"
+    }, {
+      "name" : "维度管理",
+      "children" : [ {
+        "name" : "添加维度",
+        "children" : [ {
+          "name" : "正向用例",
+          "uid" : "7af172a2303b627d",
+          "parentUid" : "367222556968830fe969c56d23a64b28",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272610398,
+            "stop" : 1716272610534,
+            "duration" : 136
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'添加维度'", "{'code': 'api_auto_test_add_dem', 'description': 'api_auto_test_add_dem', 'isDefault': 0, 'name': 'api_auto_test_add_dem'}", "'高'", "'正向用例'", "{'message': '添加维度成功！'}", "'pOst'", "'json'", "'维度管理'", "'delete FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'delete'", "None", "'http://120.46.172.186:8080/api/demension/v1/dem/addDem'" ]
+        } ],
+        "uid" : "367222556968830fe969c56d23a64b28"
+      }, {
+        "name" : "根据维度编码删除维度",
+        "children" : [ {
+          "name" : "正向用例",
+          "uid" : "cc6c15cf3215c8cc",
+          "parentUid" : "cb9e32ebc631ca9261bc484226c96537",
+          "status" : "failed",
+          "time" : {
+            "start" : 1716272632686,
+            "stop" : 1716272632817,
+            "duration" : 131
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'根据维度编码删除维度'", "{'ids': '1792803379156631552'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+        } ],
+        "uid" : "cb9e32ebc631ca9261bc484226c96537"
+      } ],
+      "uid" : "73e8dfd9412382cfca95173adf06150b"
+    }, {
+      "name" : "组织管理",
+      "children" : [ {
+        "name" : "添加组织",
+        "children" : [ {
+          "name" : "正向用例",
+          "uid" : "f7e90e36deb68600",
+          "parentUid" : "daf3ffbdadc91192b52bfb1df9f0d4e0",
+          "status" : "failed",
+          "time" : {
+            "start" : 1716272621599,
+            "stop" : 1716272621780,
+            "duration" : 181
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+        } ],
+        "uid" : "daf3ffbdadc91192b52bfb1df9f0d4e0"
+      }, {
+        "name" : "组织加入用户",
+        "children" : [ {
+          "name" : "正向用例",
+          "uid" : "10e8cf966692af2d",
+          "parentUid" : "ff6fb21f9516bd8d36114e5bed9f610c",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272621795,
+            "stop" : 1716272621848,
+            "duration" : 53
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'组织加入用户'", "{'orgCode': 'test_add_org', 'accounts': 'admin'}", "'高'", "'正向用例'", "{'state': True, 'message': '加入成功', 'value': ''}", "'POST'", "'query'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/orgUsers/addUsersForOrg'" ]
+        } ],
+        "uid" : "ff6fb21f9516bd8d36114e5bed9f610c"
+      }, {
+        "name" : "保存组织参数",
+        "children" : [ {
+          "name" : "正向用例",
+          "uid" : "15e35cc79ee68b8c",
+          "parentUid" : "3dc2353ea1ead53d1d146118c7d59cb0",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272621856,
+            "stop" : 1716272621912,
+            "duration" : 56
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'保存组织参数'", "{'query': {'orgCode': 'test_add_org'}, 'body': [{'alias': 'sz', 'value': 100}, {'alias': 'kc', 'value': '语文课'}]}", "'中'", "'正向用例'", "{'state': True, 'message': '保存组织参数成功！', 'value': ''}", "'post'", "'query|json'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/orgParam/saveOrgParams'" ]
+        } ],
+        "uid" : "3dc2353ea1ead53d1d146118c7d59cb0"
+      }, {
+        "name" : "删除组织",
+        "children" : [ {
+          "name" : "正向用例",
+          "uid" : "9a2316575f97b91e",
+          "parentUid" : "2793cc2821b7232abcd070673a778725",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272621920,
+            "stop" : 1716272621978,
+            "duration" : 58
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'删除组织'", "'test_add_org'", "'高'", "'正向用例'", "{'state': True, 'message': '删除组织成功！', 'value': ''}", "'POST'", "'text/plain'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/org/deleteOrg'" ]
+        } ],
+        "uid" : "2793cc2821b7232abcd070673a778725"
+      } ],
+      "uid" : "4bee7701e94bc8313967def29a10407c"
+    } ],
+    "uid" : "66550695002566ec8b65b624a9b94173"
+  }, {
+    "name" : "BPM-场景测试",
+    "children" : [ {
+      "name" : "认证接口",
+      "children" : [ {
+        "name" : "登录系统",
+        "children" : [ {
+          "name" : "登录--前置",
+          "uid" : "ce412b2b5e44b608",
+          "parentUid" : "3c5c9dbdff6eedda7132437c4823e890",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272632845,
+            "stop" : 1716272632940,
+            "duration" : 95
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ ]
+        } ],
+        "uid" : "3c5c9dbdff6eedda7132437c4823e890"
+      } ],
+      "uid" : "d2572c9cea4c4a294688937ffd2e595b"
+    }, {
+      "name" : "维度管理",
+      "children" : [ {
+        "name" : "添加维度",
+        "children" : [ {
+          "name" : "添加维度-依赖登录",
+          "uid" : "dd7fa74e2935b20a",
+          "parentUid" : "8153686440f02f492100449d057c22d2",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272632942,
+            "stop" : 1716272633094,
+            "duration" : 152
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ ]
+        } ],
+        "uid" : "8153686440f02f492100449d057c22d2"
+      } ],
+      "uid" : "28e7db48793fed92e49db97fac31f817"
+    }, {
+      "name" : "test",
+      "children" : [ {
+        "name" : "test",
+        "children" : [ {
+          "name" : "test用例函数-依赖登录成功和添加维度成功",
+          "uid" : "7efd9dd32f98b518",
+          "parentUid" : "72af9ba782be2d09bd4e1c28ad74d88f",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272633097,
+            "stop" : 1716272633098,
+            "duration" : 1
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ ]
+        } ],
+        "uid" : "72af9ba782be2d09bd4e1c28ad74d88f"
+      } ],
+      "uid" : "59c6ea2fb0289419214d1d68d60925f6"
+    } ],
+    "uid" : "94f1553abd732a71c34e7dce06118ae5"
+  }, {
+    "name" : "BPM系统-老张",
+    "children" : [ {
+      "name" : "维度管理",
+      "children" : [ {
+        "name" : "添加维度",
+        "children" : [ {
+          "name" : "正向用例",
+          "uid" : "510c89b87f6352b8",
+          "parentUid" : "b9d6aa28835bc38076dcf9d345270941",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272633398,
+            "stop" : 1716272633535,
+            "duration" : 137
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'添加维度'", "{'code': 'api_auto_test_add_dem', 'description': 'api_auto_test_add_dem', 'isDefault': 0, 'name': 'api_auto_test_add_dem'}", "'高'", "'正向用例'", "{'message': '添加维度成功！'}", "'pOst'", "'json'", "'维度管理'", "'delete FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'delete'", "None", "'http://120.46.172.186:8080/api/demension/v1/dem/addDem'" ]
+        } ],
+        "uid" : "b9d6aa28835bc38076dcf9d345270941"
+      }, {
+        "name" : "根据维度编码删除维度",
+        "children" : [ {
+          "name" : "正向用例",
+          "uid" : "6bce7862e8bf2a3f",
+          "parentUid" : "8d831c703d04ddd1f308d9c902ef9f96",
+          "status" : "failed",
+          "time" : {
+            "start" : 1716272655685,
+            "stop" : 1716272655817,
+            "duration" : 132
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'根据维度编码删除维度'", "{'ids': '1792803475629817856'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+        } ],
+        "uid" : "8d831c703d04ddd1f308d9c902ef9f96"
+      } ],
+      "uid" : "4e2566cdb71da7bca218fcb360e80733"
+    }, {
+      "name" : "组织管理",
+      "children" : [ {
+        "name" : "添加组织",
+        "children" : [ {
+          "name" : "正向用例",
+          "uid" : "643ca7629b09152b",
+          "parentUid" : "9a6edbc37f0b31741ce44ef6e4b3f2fa",
+          "status" : "failed",
+          "time" : {
+            "start" : 1716272644557,
+            "stop" : 1716272644742,
+            "duration" : 185
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+        } ],
+        "uid" : "9a6edbc37f0b31741ce44ef6e4b3f2fa"
+      }, {
+        "name" : "组织加入用户",
+        "children" : [ {
+          "name" : "正向用例",
+          "uid" : "adb4666aed6ea6fd",
+          "parentUid" : "3ccbcc6f69a2f5964652c7c250d86e55",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272644756,
+            "stop" : 1716272644809,
+            "duration" : 53
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'组织加入用户'", "{'orgCode': 'test_add_org', 'accounts': 'admin'}", "'高'", "'正向用例'", "{'state': True, 'message': '加入成功', 'value': ''}", "'POST'", "'query'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/orgUsers/addUsersForOrg'" ]
+        } ],
+        "uid" : "3ccbcc6f69a2f5964652c7c250d86e55"
+      }, {
+        "name" : "保存组织参数",
+        "children" : [ {
+          "name" : "正向用例",
+          "uid" : "76ee0be7403e029e",
+          "parentUid" : "2c942b594b1e70afb3b19161b365004a",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272644818,
+            "stop" : 1716272644873,
+            "duration" : 55
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'保存组织参数'", "{'query': {'orgCode': 'test_add_org'}, 'body': [{'alias': 'sz', 'value': 100}, {'alias': 'kc', 'value': '语文课'}]}", "'中'", "'正向用例'", "{'state': True, 'message': '保存组织参数成功！', 'value': ''}", "'post'", "'query|json'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/orgParam/saveOrgParams'" ]
+        } ],
+        "uid" : "2c942b594b1e70afb3b19161b365004a"
+      }, {
+        "name" : "删除组织",
+        "children" : [ {
+          "name" : "正向用例",
+          "uid" : "b6d10bbf3ce5a604",
+          "parentUid" : "7bcef793394cb1a51e5b026ae68f0aca",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272644883,
+            "stop" : 1716272644938,
+            "duration" : 55
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'删除组织'", "'test_add_org'", "'高'", "'正向用例'", "{'state': True, 'message': '删除组织成功！', 'value': ''}", "'POST'", "'text/plain'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/org/deleteOrg'" ]
+        } ],
+        "uid" : "7bcef793394cb1a51e5b026ae68f0aca"
+      } ],
+      "uid" : "31c3a4ac992804d12368ec14781f5638"
+    } ],
+    "uid" : "6e01d6d59ee91e3571e91df05295436f"
+  } ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/categories.csv

+"Category","FAILED","BROKEN","PASSED","SKIPPED","UNKNOWN"
+"Product defects","5","0","0","0","0"

InterfaceAutoTest/report/allure/html/data/categories.json

+{
+  "uid" : "4b4757e66a1912dae1a509f688f20b0f",
+  "name" : "categories",
+  "children" : [ {
+    "name" : "Product defects",
+    "children" : [ {
+      "name" : "AssertionError: assert '刷新token成功' == None\n +  where None = <built-in method get of dict object at 0x0000014F191C40C0>('message')\n +    where <built-in method get of dict object at 0x0000014F191C40C0> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwOH0.LsIqI6NBfMYmLfeFQHaiE3TLchmrNO9P3P92GkiuQQoiDTEXfelTGerbpaF-Qp4K4_45jG2cACLNB8dNwS0m-w', 'userAttrs': {}, ...}.get\n +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwOH0.LsIqI6NBfMYmLfeFQHaiE3TLchmrNO9P3P92GkiuQQoiDTEXfelTGerbpaF-Qp4K4_45jG2cACLNB8dNwS0m-w', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\n +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json",
+      "children" : [ {
+        "name" : "正向用例",
+        "uid" : "139913cc61e34bb9",
+        "parentUid" : "1b23de01d9810fce01500382107beb90",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272610326,
+          "stop" : 1716272610382,
+          "duration" : 56
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'刷新token'", "None", "'中'", "'正向用例'", "{'message': '刷新token成功'}", "'GET'", "None", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/refresh'" ]
+      } ],
+      "uid" : "1b23de01d9810fce01500382107beb90"
+    }, {
+      "name" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+      "children" : [ {
+        "name" : "正向用例",
+        "uid" : "f7e90e36deb68600",
+        "parentUid" : "4a7003532ab41bb4162e963e0553c0dd",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272621599,
+          "stop" : 1716272621780,
+          "duration" : 181
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "643ca7629b09152b",
+        "parentUid" : "4a7003532ab41bb4162e963e0553c0dd",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272644557,
+          "stop" : 1716272644742,
+          "duration" : 185
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+      } ],
+      "uid" : "4a7003532ab41bb4162e963e0553c0dd"
+    }, {
+      "name" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+      "children" : [ {
+        "name" : "正向用例",
+        "uid" : "cc6c15cf3215c8cc",
+        "parentUid" : "fc88e63a27e532a1ff14905d99754e1d",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272632686,
+          "stop" : 1716272632817,
+          "duration" : 131
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'根据维度编码删除维度'", "{'ids': '1792803379156631552'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "6bce7862e8bf2a3f",
+        "parentUid" : "fc88e63a27e532a1ff14905d99754e1d",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272655685,
+          "stop" : 1716272655817,
+          "duration" : 132
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'根据维度编码删除维度'", "{'ids': '1792803475629817856'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+      } ],
+      "uid" : "fc88e63a27e532a1ff14905d99754e1d"
+    } ],
+    "uid" : "8fb3a91ba5aaf9de24cc8a92edc82b5d"
+  } ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/packages.json

+{
+  "uid" : "83edc06c07f9ae9e47eb6dd1b683e4e2",
+  "name" : "packages",
+  "children" : [ {
+    "name" : "test_case",
+    "children" : [ {
+      "name" : "test_demo.test_bpm",
+      "children" : [ {
+        "name" : "正向用例-正确输入用户名和密码",
+        "uid" : "80142e22de024a60",
+        "parentUid" : "408359e4381982766f71d289f282adbb",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272598748,
+          "stop" : 1716272598811,
+          "duration" : 63
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'登录系统'", "{'username': 'admin', 'password': 'MTIzNDU2'}", "'高'", "'正向用例-正确输入用户名和密码'", "{'username': '超级管理员', 'loginStatus': True, 'account': 'admin'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+      }, {
+        "name" : "反向用例-用户名正确,密码为空",
+        "uid" : "1bd3c031f056ab2e",
+        "parentUid" : "408359e4381982766f71d289f282adbb",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272598829,
+          "stop" : 1716272598886,
+          "duration" : 57
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'登录系统'", "{'username': 'admin', 'password': ''}", "'中'", "'反向用例-用户名正确,密码为空'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+      }, {
+        "name" : "反向用例-用户名正确,密码过长",
+        "uid" : "c26c17d72f28aa7f",
+        "parentUid" : "408359e4381982766f71d289f282adbb",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272598895,
+          "stop" : 1716272598989,
+          "duration" : 94
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'登录系统'", "{'username': 'admin', 'password': 'MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2'}", "'中'", "'反向用例-用户名正确,密码过长'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+      }, {
+        "name" : "反向用例-用户名正确,密码过短",
+        "uid" : "e425d3e0108cef57",
+        "parentUid" : "408359e4381982766f71d289f282adbb",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272598998,
+          "stop" : 1716272599093,
+          "duration" : 95
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'登录系统'", "{'username': 'admin', 'password': 'm'}", "'中'", "'反向用例-用户名正确,密码过短'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+      }, {
+        "name" : "反向用例-用户名正确,密码为特殊字符",
+        "uid" : "d093b8587a3ab4f3",
+        "parentUid" : "408359e4381982766f71d289f282adbb",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272599103,
+          "stop" : 1716272599203,
+          "duration" : 100
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'登录系统'", "{'username': 'admin', 'password': '☯㍿卍卐'}", "'中'", "'反向用例-用户名正确,密码为特殊字符'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+      }, {
+        "name" : "反向用例-密码正确,用户名为空",
+        "uid" : "5532c9175fb2354e",
+        "parentUid" : "408359e4381982766f71d289f282adbb",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272599213,
+          "stop" : 1716272599306,
+          "duration" : 93
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'登录系统'", "{'username': '', 'password': 'MTIzNDU2'}", "'中'", "'反向用例-密码正确,用户名为空'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+      }, {
+        "name" : "反向用例-密码正确,用户名过长",
+        "uid" : "8142d41860b04b15",
+        "parentUid" : "408359e4381982766f71d289f282adbb",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272599315,
+          "stop" : 1716272599407,
+          "duration" : 92
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'登录系统'", "{'username': 'adminadminadminadmin', 'password': 'MTIzNDU2'}", "'中'", "'反向用例-密码正确,用户名过长'", "{'message': '账号或密码错误'}", "'POST'", "'json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+      }, {
+        "name" : "反向用例-密码正确,用户名过短",
+        "uid" : "96596e0fab9d3415",
+        "parentUid" : "408359e4381982766f71d289f282adbb",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272599418,
+          "stop" : 1716272599517,
+          "duration" : 99
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'登录系统'", "{'username': 'a', 'password': 'MTIzNDU2'}", "'中'", "'反向用例-密码正确,用户名过短'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+      }, {
+        "name" : "反向用例-密码正确,用户名为特殊字符",
+        "uid" : "5b0b595f880fe013",
+        "parentUid" : "408359e4381982766f71d289f282adbb",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272599527,
+          "stop" : 1716272599627,
+          "duration" : 100
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'登录系统'", "{'username': '☯㍿卍卐', 'password': 'MTIzNDU2'}", "'中'", "'反向用例-密码正确,用户名为特殊字符'", "{'message': '账号或密码错误'}", "'POST'", "'json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+      }, {
+        "name" : "反向用例-密码正确,用户名错误",
+        "uid" : "a0b87df8f50dc316",
+        "parentUid" : "408359e4381982766f71d289f282adbb",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272599640,
+          "stop" : 1716272599737,
+          "duration" : 97
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'登录系统'", "{'username': 'admin123', 'password': 'MTIzNDU2'}", "'中'", "'反向用例-密码正确,用户名错误'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "139913cc61e34bb9",
+        "parentUid" : "408359e4381982766f71d289f282adbb",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272610326,
+          "stop" : 1716272610382,
+          "duration" : 56
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'刷新token'", "None", "'中'", "'正向用例'", "{'message': '刷新token成功'}", "'GET'", "None", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/refresh'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "7af172a2303b627d",
+        "parentUid" : "408359e4381982766f71d289f282adbb",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272610398,
+          "stop" : 1716272610534,
+          "duration" : 136
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'添加维度'", "{'code': 'api_auto_test_add_dem', 'description': 'api_auto_test_add_dem', 'isDefault': 0, 'name': 'api_auto_test_add_dem'}", "'高'", "'正向用例'", "{'message': '添加维度成功！'}", "'pOst'", "'json'", "'维度管理'", "'delete FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'delete'", "None", "'http://120.46.172.186:8080/api/demension/v1/dem/addDem'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "f7e90e36deb68600",
+        "parentUid" : "408359e4381982766f71d289f282adbb",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272621599,
+          "stop" : 1716272621780,
+          "duration" : 181
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "10e8cf966692af2d",
+        "parentUid" : "408359e4381982766f71d289f282adbb",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272621795,
+          "stop" : 1716272621848,
+          "duration" : 53
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'组织加入用户'", "{'orgCode': 'test_add_org', 'accounts': 'admin'}", "'高'", "'正向用例'", "{'state': True, 'message': '加入成功', 'value': ''}", "'POST'", "'query'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/orgUsers/addUsersForOrg'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "15e35cc79ee68b8c",
+        "parentUid" : "408359e4381982766f71d289f282adbb",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272621856,
+          "stop" : 1716272621912,
+          "duration" : 56
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'保存组织参数'", "{'query': {'orgCode': 'test_add_org'}, 'body': [{'alias': 'sz', 'value': 100}, {'alias': 'kc', 'value': '语文课'}]}", "'中'", "'正向用例'", "{'state': True, 'message': '保存组织参数成功！', 'value': ''}", "'post'", "'query|json'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/orgParam/saveOrgParams'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "9a2316575f97b91e",
+        "parentUid" : "408359e4381982766f71d289f282adbb",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272621920,
+          "stop" : 1716272621978,
+          "duration" : 58
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'删除组织'", "'test_add_org'", "'高'", "'正向用例'", "{'state': True, 'message': '删除组织成功！', 'value': ''}", "'POST'", "'text/plain'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/org/deleteOrg'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "cc6c15cf3215c8cc",
+        "parentUid" : "408359e4381982766f71d289f282adbb",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272632686,
+          "stop" : 1716272632817,
+          "duration" : 131
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'根据维度编码删除维度'", "{'ids': '1792803379156631552'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+      } ],
+      "uid" : "test_demo.test_bpm"
+    }, {
+      "name" : "test_dependency.test_dependency",
+      "children" : [ {
+        "name" : "登录--前置",
+        "uid" : "ce412b2b5e44b608",
+        "parentUid" : "a275d33d9bda480afc64576a664c55db",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272632845,
+          "stop" : 1716272632940,
+          "duration" : 95
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ ]
+      }, {
+        "name" : "添加维度-依赖登录",
+        "uid" : "dd7fa74e2935b20a",
+        "parentUid" : "a275d33d9bda480afc64576a664c55db",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272632942,
+          "stop" : 1716272633094,
+          "duration" : 152
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ ]
+      }, {
+        "name" : "test用例函数-依赖登录成功和添加维度成功",
+        "uid" : "7efd9dd32f98b518",
+        "parentUid" : "a275d33d9bda480afc64576a664c55db",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272633097,
+          "stop" : 1716272633098,
+          "duration" : 1
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ ]
+      } ],
+      "uid" : "test_dependency.test_dependency"
+    }, {
+      "name" : "test_mirZhang.test_bpm",
+      "children" : [ {
+        "name" : "正向用例",
+        "uid" : "510c89b87f6352b8",
+        "parentUid" : "fbaa16879cfc96f99b767496d76ca64d",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272633398,
+          "stop" : 1716272633535,
+          "duration" : 137
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'添加维度'", "{'code': 'api_auto_test_add_dem', 'description': 'api_auto_test_add_dem', 'isDefault': 0, 'name': 'api_auto_test_add_dem'}", "'高'", "'正向用例'", "{'message': '添加维度成功！'}", "'pOst'", "'json'", "'维度管理'", "'delete FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'delete'", "None", "'http://120.46.172.186:8080/api/demension/v1/dem/addDem'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "643ca7629b09152b",
+        "parentUid" : "fbaa16879cfc96f99b767496d76ca64d",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272644557,
+          "stop" : 1716272644742,
+          "duration" : 185
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "adb4666aed6ea6fd",
+        "parentUid" : "fbaa16879cfc96f99b767496d76ca64d",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272644756,
+          "stop" : 1716272644809,
+          "duration" : 53
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'组织加入用户'", "{'orgCode': 'test_add_org', 'accounts': 'admin'}", "'高'", "'正向用例'", "{'state': True, 'message': '加入成功', 'value': ''}", "'POST'", "'query'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/orgUsers/addUsersForOrg'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "76ee0be7403e029e",
+        "parentUid" : "fbaa16879cfc96f99b767496d76ca64d",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272644818,
+          "stop" : 1716272644873,
+          "duration" : 55
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'保存组织参数'", "{'query': {'orgCode': 'test_add_org'}, 'body': [{'alias': 'sz', 'value': 100}, {'alias': 'kc', 'value': '语文课'}]}", "'中'", "'正向用例'", "{'state': True, 'message': '保存组织参数成功！', 'value': ''}", "'post'", "'query|json'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/orgParam/saveOrgParams'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "b6d10bbf3ce5a604",
+        "parentUid" : "fbaa16879cfc96f99b767496d76ca64d",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272644883,
+          "stop" : 1716272644938,
+          "duration" : 55
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'删除组织'", "'test_add_org'", "'高'", "'正向用例'", "{'state': True, 'message': '删除组织成功！', 'value': ''}", "'POST'", "'text/plain'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/org/deleteOrg'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "6bce7862e8bf2a3f",
+        "parentUid" : "fbaa16879cfc96f99b767496d76ca64d",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272655685,
+          "stop" : 1716272655817,
+          "duration" : 132
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'根据维度编码删除维度'", "{'ids': '1792803475629817856'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+      } ],
+      "uid" : "test_mirZhang.test_bpm"
+    } ],
+    "uid" : "3b2e467b921b0ea8d4803b9c79d92d0c"
+  } ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/suites.csv

+"Status","Start Time","Stop Time","Duration in ms","Parent Suite","Suite","Sub Suite","Test Class","Test Method","Name","Description"
+"passed","Tue May 21 14:23:19 CST 2024","Tue May 21 14:23:19 CST 2024","92","test_case.test_demo","test_bpm","TestBPM","","","反向用例-密码正确,用户名过长",""
+"failed","Tue May 21 14:23:30 CST 2024","Tue May 21 14:23:30 CST 2024","56","test_case.test_demo","test_bpm","TestBPM","","","正向用例",""
+"passed","Tue May 21 14:23:18 CST 2024","Tue May 21 14:23:18 CST 2024","63","test_case.test_demo","test_bpm","TestBPM","","","正向用例-正确输入用户名和密码",""
+"failed","Tue May 21 14:23:52 CST 2024","Tue May 21 14:23:52 CST 2024","131","test_case.test_demo","test_bpm","TestBPM","","","正向用例",""
+"passed","Tue May 21 14:23:18 CST 2024","Tue May 21 14:23:18 CST 2024","57","test_case.test_demo","test_bpm","TestBPM","","","反向用例-用户名正确,密码为空",""
+"passed","Tue May 21 14:23:19 CST 2024","Tue May 21 14:23:19 CST 2024","100","test_case.test_demo","test_bpm","TestBPM","","","反向用例-密码正确,用户名为特殊字符",""
+"passed","Tue May 21 14:23:41 CST 2024","Tue May 21 14:23:41 CST 2024","58","test_case.test_demo","test_bpm","TestBPM","","","正向用例",""
+"passed","Tue May 21 14:24:04 CST 2024","Tue May 21 14:24:04 CST 2024","55","test_case.test_mirZhang","test_bpm","TestBPM","","","正向用例",""
+"passed","Tue May 21 14:23:19 CST 2024","Tue May 21 14:23:19 CST 2024","93","test_case.test_demo","test_bpm","TestBPM","","","反向用例-密码正确,用户名为空",""
+"passed","Tue May 21 14:24:04 CST 2024","Tue May 21 14:24:04 CST 2024","55","test_case.test_mirZhang","test_bpm","TestBPM","","","正向用例",""
+"passed","Tue May 21 14:24:04 CST 2024","Tue May 21 14:24:04 CST 2024","53","test_case.test_mirZhang","test_bpm","TestBPM","","","正向用例",""
+"passed","Tue May 21 14:23:30 CST 2024","Tue May 21 14:23:30 CST 2024","136","test_case.test_demo","test_bpm","TestBPM","","","正向用例",""
+"failed","Tue May 21 14:23:41 CST 2024","Tue May 21 14:23:41 CST 2024","181","test_case.test_demo","test_bpm","TestBPM","","","正向用例",""
+"passed","Tue May 21 14:23:41 CST 2024","Tue May 21 14:23:41 CST 2024","53","test_case.test_demo","test_bpm","TestBPM","","","正向用例",""
+"passed","Tue May 21 14:23:41 CST 2024","Tue May 21 14:23:41 CST 2024","56","test_case.test_demo","test_bpm","TestBPM","","","正向用例",""
+"passed","Tue May 21 14:23:52 CST 2024","Tue May 21 14:23:52 CST 2024","95","test_case.test_dependency","test_dependency","","","","登录--前置",""
+"passed","Tue May 21 14:23:53 CST 2024","Tue May 21 14:23:53 CST 2024","137","test_case.test_mirZhang","test_bpm","TestBPM","","","正向用例",""
+"failed","Tue May 21 14:24:15 CST 2024","Tue May 21 14:24:15 CST 2024","132","test_case.test_mirZhang","test_bpm","TestBPM","","","正向用例",""
+"passed","Tue May 21 14:23:19 CST 2024","Tue May 21 14:23:19 CST 2024","97","test_case.test_demo","test_bpm","TestBPM","","","反向用例-密码正确,用户名错误",""
+"passed","Tue May 21 14:23:18 CST 2024","Tue May 21 14:23:18 CST 2024","94","test_case.test_demo","test_bpm","TestBPM","","","反向用例-用户名正确,密码过长",""
+"passed","Tue May 21 14:23:19 CST 2024","Tue May 21 14:23:19 CST 2024","100","test_case.test_demo","test_bpm","TestBPM","","","反向用例-用户名正确,密码为特殊字符",""
+"passed","Tue May 21 14:23:52 CST 2024","Tue May 21 14:23:53 CST 2024","152","test_case.test_dependency","test_dependency","","","","添加维度-依赖登录",""
+"failed","Tue May 21 14:24:04 CST 2024","Tue May 21 14:24:04 CST 2024","185","test_case.test_mirZhang","test_bpm","TestBPM","","","正向用例",""
+"passed","Tue May 21 14:23:18 CST 2024","Tue May 21 14:23:19 CST 2024","95","test_case.test_demo","test_bpm","TestBPM","","","反向用例-用户名正确,密码过短",""
+"passed","Tue May 21 14:23:53 CST 2024","Tue May 21 14:23:53 CST 2024","1","test_case.test_dependency","test_dependency","","","","test用例函数-依赖登录成功和添加维度成功",""
+"passed","Tue May 21 14:23:19 CST 2024","Tue May 21 14:23:19 CST 2024","99","test_case.test_demo","test_bpm","TestBPM","","","反向用例-密码正确,用户名过短",""

InterfaceAutoTest/report/allure/html/data/suites.json

+{
+  "uid" : "98d3104e051c652961429bf95fa0b5d6",
+  "name" : "suites",
+  "children" : [ {
+    "name" : "test_case.test_demo",
+    "children" : [ {
+      "name" : "test_bpm",
+      "children" : [ {
+        "name" : "TestBPM",
+        "children" : [ {
+          "name" : "正向用例-正确输入用户名和密码",
+          "uid" : "80142e22de024a60",
+          "parentUid" : "ef69bf2bb1b41f3ca3f11617396f6a81",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272598748,
+            "stop" : 1716272598811,
+            "duration" : 63
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'登录系统'", "{'username': 'admin', 'password': 'MTIzNDU2'}", "'高'", "'正向用例-正确输入用户名和密码'", "{'username': '超级管理员', 'loginStatus': True, 'account': 'admin'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+        }, {
+          "name" : "反向用例-用户名正确,密码为空",
+          "uid" : "1bd3c031f056ab2e",
+          "parentUid" : "ef69bf2bb1b41f3ca3f11617396f6a81",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272598829,
+            "stop" : 1716272598886,
+            "duration" : 57
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'登录系统'", "{'username': 'admin', 'password': ''}", "'中'", "'反向用例-用户名正确,密码为空'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+        }, {
+          "name" : "反向用例-用户名正确,密码过长",
+          "uid" : "c26c17d72f28aa7f",
+          "parentUid" : "ef69bf2bb1b41f3ca3f11617396f6a81",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272598895,
+            "stop" : 1716272598989,
+            "duration" : 94
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'登录系统'", "{'username': 'admin', 'password': 'MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2'}", "'中'", "'反向用例-用户名正确,密码过长'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+        }, {
+          "name" : "反向用例-用户名正确,密码过短",
+          "uid" : "e425d3e0108cef57",
+          "parentUid" : "ef69bf2bb1b41f3ca3f11617396f6a81",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272598998,
+            "stop" : 1716272599093,
+            "duration" : 95
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'登录系统'", "{'username': 'admin', 'password': 'm'}", "'中'", "'反向用例-用户名正确,密码过短'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+        }, {
+          "name" : "反向用例-用户名正确,密码为特殊字符",
+          "uid" : "d093b8587a3ab4f3",
+          "parentUid" : "ef69bf2bb1b41f3ca3f11617396f6a81",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272599103,
+            "stop" : 1716272599203,
+            "duration" : 100
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'登录系统'", "{'username': 'admin', 'password': '☯㍿卍卐'}", "'中'", "'反向用例-用户名正确,密码为特殊字符'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+        }, {
+          "name" : "反向用例-密码正确,用户名为空",
+          "uid" : "5532c9175fb2354e",
+          "parentUid" : "ef69bf2bb1b41f3ca3f11617396f6a81",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272599213,
+            "stop" : 1716272599306,
+            "duration" : 93
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'登录系统'", "{'username': '', 'password': 'MTIzNDU2'}", "'中'", "'反向用例-密码正确,用户名为空'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+        }, {
+          "name" : "反向用例-密码正确,用户名过长",
+          "uid" : "8142d41860b04b15",
+          "parentUid" : "ef69bf2bb1b41f3ca3f11617396f6a81",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272599315,
+            "stop" : 1716272599407,
+            "duration" : 92
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'登录系统'", "{'username': 'adminadminadminadmin', 'password': 'MTIzNDU2'}", "'中'", "'反向用例-密码正确,用户名过长'", "{'message': '账号或密码错误'}", "'POST'", "'json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+        }, {
+          "name" : "反向用例-密码正确,用户名过短",
+          "uid" : "96596e0fab9d3415",
+          "parentUid" : "ef69bf2bb1b41f3ca3f11617396f6a81",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272599418,
+            "stop" : 1716272599517,
+            "duration" : 99
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'登录系统'", "{'username': 'a', 'password': 'MTIzNDU2'}", "'中'", "'反向用例-密码正确,用户名过短'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+        }, {
+          "name" : "反向用例-密码正确,用户名为特殊字符",
+          "uid" : "5b0b595f880fe013",
+          "parentUid" : "ef69bf2bb1b41f3ca3f11617396f6a81",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272599527,
+            "stop" : 1716272599627,
+            "duration" : 100
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'登录系统'", "{'username': '☯㍿卍卐', 'password': 'MTIzNDU2'}", "'中'", "'反向用例-密码正确,用户名为特殊字符'", "{'message': '账号或密码错误'}", "'POST'", "'json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+        }, {
+          "name" : "反向用例-密码正确,用户名错误",
+          "uid" : "a0b87df8f50dc316",
+          "parentUid" : "ef69bf2bb1b41f3ca3f11617396f6a81",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272599640,
+            "stop" : 1716272599737,
+            "duration" : 97
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'登录系统'", "{'username': 'admin123', 'password': 'MTIzNDU2'}", "'中'", "'反向用例-密码正确,用户名错误'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+        }, {
+          "name" : "正向用例",
+          "uid" : "139913cc61e34bb9",
+          "parentUid" : "ef69bf2bb1b41f3ca3f11617396f6a81",
+          "status" : "failed",
+          "time" : {
+            "start" : 1716272610326,
+            "stop" : 1716272610382,
+            "duration" : 56
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'刷新token'", "None", "'中'", "'正向用例'", "{'message': '刷新token成功'}", "'GET'", "None", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/refresh'" ]
+        }, {
+          "name" : "正向用例",
+          "uid" : "7af172a2303b627d",
+          "parentUid" : "ef69bf2bb1b41f3ca3f11617396f6a81",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272610398,
+            "stop" : 1716272610534,
+            "duration" : 136
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'添加维度'", "{'code': 'api_auto_test_add_dem', 'description': 'api_auto_test_add_dem', 'isDefault': 0, 'name': 'api_auto_test_add_dem'}", "'高'", "'正向用例'", "{'message': '添加维度成功！'}", "'pOst'", "'json'", "'维度管理'", "'delete FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'delete'", "None", "'http://120.46.172.186:8080/api/demension/v1/dem/addDem'" ]
+        }, {
+          "name" : "正向用例",
+          "uid" : "f7e90e36deb68600",
+          "parentUid" : "ef69bf2bb1b41f3ca3f11617396f6a81",
+          "status" : "failed",
+          "time" : {
+            "start" : 1716272621599,
+            "stop" : 1716272621780,
+            "duration" : 181
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+        }, {
+          "name" : "正向用例",
+          "uid" : "10e8cf966692af2d",
+          "parentUid" : "ef69bf2bb1b41f3ca3f11617396f6a81",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272621795,
+            "stop" : 1716272621848,
+            "duration" : 53
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'组织加入用户'", "{'orgCode': 'test_add_org', 'accounts': 'admin'}", "'高'", "'正向用例'", "{'state': True, 'message': '加入成功', 'value': ''}", "'POST'", "'query'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/orgUsers/addUsersForOrg'" ]
+        }, {
+          "name" : "正向用例",
+          "uid" : "15e35cc79ee68b8c",
+          "parentUid" : "ef69bf2bb1b41f3ca3f11617396f6a81",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272621856,
+            "stop" : 1716272621912,
+            "duration" : 56
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'保存组织参数'", "{'query': {'orgCode': 'test_add_org'}, 'body': [{'alias': 'sz', 'value': 100}, {'alias': 'kc', 'value': '语文课'}]}", "'中'", "'正向用例'", "{'state': True, 'message': '保存组织参数成功！', 'value': ''}", "'post'", "'query|json'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/orgParam/saveOrgParams'" ]
+        }, {
+          "name" : "正向用例",
+          "uid" : "9a2316575f97b91e",
+          "parentUid" : "ef69bf2bb1b41f3ca3f11617396f6a81",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272621920,
+            "stop" : 1716272621978,
+            "duration" : 58
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'删除组织'", "'test_add_org'", "'高'", "'正向用例'", "{'state': True, 'message': '删除组织成功！', 'value': ''}", "'POST'", "'text/plain'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/org/deleteOrg'" ]
+        }, {
+          "name" : "正向用例",
+          "uid" : "cc6c15cf3215c8cc",
+          "parentUid" : "ef69bf2bb1b41f3ca3f11617396f6a81",
+          "status" : "failed",
+          "time" : {
+            "start" : 1716272632686,
+            "stop" : 1716272632817,
+            "duration" : 131
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'根据维度编码删除维度'", "{'ids': '1792803379156631552'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+        } ],
+        "uid" : "ef69bf2bb1b41f3ca3f11617396f6a81"
+      } ],
+      "uid" : "5f023a47dd31329b45d44784c00131e4"
+    } ],
+    "uid" : "7a8b7e46177bbd4d1efa8551fea4a38d"
+  }, {
+    "name" : "test_case.test_dependency",
+    "children" : [ {
+      "name" : "test_dependency",
+      "children" : [ {
+        "name" : "登录--前置",
+        "uid" : "ce412b2b5e44b608",
+        "parentUid" : "fc6c9efd9546dcb429acba88a29f612b",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272632845,
+          "stop" : 1716272632940,
+          "duration" : 95
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ ]
+      }, {
+        "name" : "添加维度-依赖登录",
+        "uid" : "dd7fa74e2935b20a",
+        "parentUid" : "fc6c9efd9546dcb429acba88a29f612b",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272632942,
+          "stop" : 1716272633094,
+          "duration" : 152
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ ]
+      }, {
+        "name" : "test用例函数-依赖登录成功和添加维度成功",
+        "uid" : "7efd9dd32f98b518",
+        "parentUid" : "fc6c9efd9546dcb429acba88a29f612b",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272633097,
+          "stop" : 1716272633098,
+          "duration" : 1
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ ]
+      } ],
+      "uid" : "fc6c9efd9546dcb429acba88a29f612b"
+    } ],
+    "uid" : "5fa37ee52138cac4807b87b482b5d721"
+  }, {
+    "name" : "test_case.test_mirZhang",
+    "children" : [ {
+      "name" : "test_bpm",
+      "children" : [ {
+        "name" : "TestBPM",
+        "children" : [ {
+          "name" : "正向用例",
+          "uid" : "510c89b87f6352b8",
+          "parentUid" : "c76c9721dfc2eeaf36e23d7cef2f161e",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272633398,
+            "stop" : 1716272633535,
+            "duration" : 137
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'添加维度'", "{'code': 'api_auto_test_add_dem', 'description': 'api_auto_test_add_dem', 'isDefault': 0, 'name': 'api_auto_test_add_dem'}", "'高'", "'正向用例'", "{'message': '添加维度成功！'}", "'pOst'", "'json'", "'维度管理'", "'delete FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'delete'", "None", "'http://120.46.172.186:8080/api/demension/v1/dem/addDem'" ]
+        }, {
+          "name" : "正向用例",
+          "uid" : "643ca7629b09152b",
+          "parentUid" : "c76c9721dfc2eeaf36e23d7cef2f161e",
+          "status" : "failed",
+          "time" : {
+            "start" : 1716272644557,
+            "stop" : 1716272644742,
+            "duration" : 185
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+        }, {
+          "name" : "正向用例",
+          "uid" : "adb4666aed6ea6fd",
+          "parentUid" : "c76c9721dfc2eeaf36e23d7cef2f161e",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272644756,
+            "stop" : 1716272644809,
+            "duration" : 53
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'组织加入用户'", "{'orgCode': 'test_add_org', 'accounts': 'admin'}", "'高'", "'正向用例'", "{'state': True, 'message': '加入成功', 'value': ''}", "'POST'", "'query'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/orgUsers/addUsersForOrg'" ]
+        }, {
+          "name" : "正向用例",
+          "uid" : "76ee0be7403e029e",
+          "parentUid" : "c76c9721dfc2eeaf36e23d7cef2f161e",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272644818,
+            "stop" : 1716272644873,
+            "duration" : 55
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'保存组织参数'", "{'query': {'orgCode': 'test_add_org'}, 'body': [{'alias': 'sz', 'value': 100}, {'alias': 'kc', 'value': '语文课'}]}", "'中'", "'正向用例'", "{'state': True, 'message': '保存组织参数成功！', 'value': ''}", "'post'", "'query|json'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/orgParam/saveOrgParams'" ]
+        }, {
+          "name" : "正向用例",
+          "uid" : "b6d10bbf3ce5a604",
+          "parentUid" : "c76c9721dfc2eeaf36e23d7cef2f161e",
+          "status" : "passed",
+          "time" : {
+            "start" : 1716272644883,
+            "stop" : 1716272644938,
+            "duration" : 55
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'删除组织'", "'test_add_org'", "'高'", "'正向用例'", "{'state': True, 'message': '删除组织成功！', 'value': ''}", "'POST'", "'text/plain'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/org/deleteOrg'" ]
+        }, {
+          "name" : "正向用例",
+          "uid" : "6bce7862e8bf2a3f",
+          "parentUid" : "c76c9721dfc2eeaf36e23d7cef2f161e",
+          "status" : "failed",
+          "time" : {
+            "start" : 1716272655685,
+            "stop" : 1716272655817,
+            "duration" : 132
+          },
+          "flaky" : false,
+          "newFailed" : false,
+          "parameters" : [ "'根据维度编码删除维度'", "{'ids': '1792803475629817856'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+        } ],
+        "uid" : "c76c9721dfc2eeaf36e23d7cef2f161e"
+      } ],
+      "uid" : "67ba6791b97e745dd37a3c2e47827490"
+    } ],
+    "uid" : "663b5eac116b5bc6651b8e1e82719203"
+  } ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/10e8cf966692af2d.json

+{
+  "uid" : "10e8cf966692af2d",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "385bda31fe152e15cd1fc6b7817225aa",
+  "time" : {
+    "start" : 1716272621795,
+    "stop" : 1716272621848,
+    "duration" : 53
+  },
+  "status" : "passed",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "passed",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "7201d70001e141e",
+      "name" : "log",
+      "source" : "7201d70001e141e.txt",
+      "type" : "text/plain",
+      "size" : 276
+    }, {
+      "uid" : "b40117ab71b81a91",
+      "name" : "stdout",
+      "source" : "b40117ab71b81a91.txt",
+      "type" : "text/plain",
+      "size" : 7
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 2,
+    "shouldDisplayMessage" : false
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "组织管理"
+  }, {
+    "name" : "story",
+    "value" : "组织加入用户"
+  }, {
+    "name" : "severity",
+    "value" : "高"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'组织加入用户'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'orgCode': 'test_add_org', 'accounts': 'admin'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'高'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'state': True, 'message': '加入成功', 'value': ''}"
+  }, {
+    "name" : "method",
+    "value" : "'POST'"
+  }, {
+    "name" : "mime",
+    "value" : "'query'"
+  }, {
+    "name" : "module_name",
+    "value" : "'组织管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "None"
+  }, {
+    "name" : "sql_type",
+    "value" : "None"
+  }, {
+    "name" : "update_key",
+    "value" : "None"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/org/v1/orgUsers/addUsersForOrg'"
+  } ],
+  "links" : [ ],
+  "hidden" : false,
+  "retry" : false,
+  "extra" : {
+    "severity" : "normal",
+    "retries" : [ ],
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "10e8cf966692af2d.json",
+  "parameterValues" : [ "'组织加入用户'", "{'orgCode': 'test_add_org', 'accounts': 'admin'}", "'高'", "'正向用例'", "{'state': True, 'message': '加入成功', 'value': ''}", "'POST'", "'query'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/orgUsers/addUsersForOrg'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/12eaadd487a58cd.json

+{
+  "uid" : "12eaadd487a58cd",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm",
+  "historyId" : "f0f670cbfec7a9680aec241c756307a6",
+  "time" : {
+    "start" : 1716272649197,
+    "stop" : 1716272649328,
+    "duration" : 131
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "208c263728b0d9ca",
+      "name" : "log",
+      "source" : "208c263728b0d9ca.txt",
+      "type" : "text/plain",
+      "size" : 735
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "维度管理"
+  }, {
+    "name" : "story",
+    "value" : "根据维度编码删除维度"
+  }, {
+    "name" : "severity",
+    "value" : "中"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-老张"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_mirZhang"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_mirZhang.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'根据维度编码删除维度'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'ids': '1792803475629817856'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'中'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '删除维度成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'DELETE'"
+  }, {
+    "name" : "mime",
+    "value" : "'query'"
+  }, {
+    "name" : "module_name",
+    "value" : "'维度管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"
+  }, {
+    "name" : "sql_type",
+    "value" : "'select'"
+  }, {
+    "name" : "update_key",
+    "value" : "'ids'"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'"
+  } ],
+  "links" : [ ],
+  "hidden" : true,
+  "retry" : true,
+  "extra" : {
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "12eaadd487a58cd.json",
+  "parameterValues" : [ "'根据维度编码删除维度'", "{'ids': '1792803475629817856'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/139913cc61e34bb9.json

+{
+  "uid" : "139913cc61e34bb9",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "1dcae5f805bddffd6ce19e14c8b3458b",
+  "time" : {
+    "start" : 1716272610326,
+    "stop" : 1716272610382,
+    "duration" : 56
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '刷新token成功' == None\n +  where None = <built-in method get of dict object at 0x0000014F191C40C0>('message')\n +    where <built-in method get of dict object at 0x0000014F191C40C0> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwOH0.LsIqI6NBfMYmLfeFQHaiE3TLchmrNO9P3P92GkiuQQoiDTEXfelTGerbpaF-Qp4K4_45jG2cACLNB8dNwS0m-w', 'userAttrs': {}, ...}.get\n +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwOH0.LsIqI6NBfMYmLfeFQHaiE3TLchmrNO9P3P92GkiuQQoiDTEXfelTGerbpaF-Qp4K4_45jG2cACLNB8dNwS0m-w', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\n +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '刷新token成功' == None\nE                +  where None = <built-in method get of dict object at 0x0000014F191C40C0>('message')\nE                +    where <built-in method get of dict object at 0x0000014F191C40C0> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwOH0.LsIqI6NBfMYmLfeFQHaiE3TLchmrNO9P3P92GkiuQQoiDTEXfelTGerbpaF-Qp4K4_45jG2cACLNB8dNwS0m-w', 'userAttrs': {}, ...}.get\nE                +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwOH0.LsIqI6NBfMYmLfeFQHaiE3TLchmrNO9P3P92GkiuQQoiDTEXfelTGerbpaF-Qp4K4_45jG2cACLNB8dNwS0m-w', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\nE                +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '刷新token成功' == None\n +  where None = <built-in method get of dict object at 0x0000014F191C40C0>('message')\n +    where <built-in method get of dict object at 0x0000014F191C40C0> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwOH0.LsIqI6NBfMYmLfeFQHaiE3TLchmrNO9P3P92GkiuQQoiDTEXfelTGerbpaF-Qp4K4_45jG2cACLNB8dNwS0m-w', 'userAttrs': {}, ...}.get\n +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwOH0.LsIqI6NBfMYmLfeFQHaiE3TLchmrNO9P3P92GkiuQQoiDTEXfelTGerbpaF-Qp4K4_45jG2cACLNB8dNwS0m-w', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\n +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '刷新token成功' == None\nE                +  where None = <built-in method get of dict object at 0x0000014F191C40C0>('message')\nE                +    where <built-in method get of dict object at 0x0000014F191C40C0> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwOH0.LsIqI6NBfMYmLfeFQHaiE3TLchmrNO9P3P92GkiuQQoiDTEXfelTGerbpaF-Qp4K4_45jG2cACLNB8dNwS0m-w', 'userAttrs': {}, ...}.get\nE                +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwOH0.LsIqI6NBfMYmLfeFQHaiE3TLchmrNO9P3P92GkiuQQoiDTEXfelTGerbpaF-Qp4K4_45jG2cACLNB8dNwS0m-w', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\nE                +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "85bb81ed805a1bc2",
+      "name" : "log",
+      "source" : "85bb81ed805a1bc2.txt",
+      "type" : "text/plain",
+      "size" : 2639
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "认证接口"
+  }, {
+    "name" : "story",
+    "value" : "刷新token"
+  }, {
+    "name" : "severity",
+    "value" : "中"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'刷新token'"
+  }, {
+    "name" : "case_data",
+    "value" : "None"
+  }, {
+    "name" : "case_level",
+    "value" : "'中'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '刷新token成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'GET'"
+  }, {
+    "name" : "mime",
+    "value" : "None"
+  }, {
+    "name" : "module_name",
+    "value" : "'认证接口'"
+  }, {
+    "name" : "sql_data",
+    "value" : "None"
+  }, {
+    "name" : "sql_type",
+    "value" : "None"
+  }, {
+    "name" : "update_key",
+    "value" : "None"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/refresh'"
+  } ],
+  "links" : [ ],
+  "hidden" : false,
+  "retry" : false,
+  "extra" : {
+    "severity" : "normal",
+    "retries" : [ {
+      "uid" : "272c438f0bed80b",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '刷新token成功' == None\n +  where None = <built-in method get of dict object at 0x0000014F19157380>('message')\n +    where <built-in method get of dict object at 0x0000014F19157380> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwNn0.W_ynWuu-79lzZS5ScuftmKzI8_B3z3llQ0gnSpahTsvIdUBKeaos4loXKk4DrzU4CGbchLTa5lK48yzcFXXQoA', 'userAttrs': {}, ...}.get\n +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwNn0.W_ynWuu-79lzZS5ScuftmKzI8_B3z3llQ0gnSpahTsvIdUBKeaos4loXKk4DrzU4CGbchLTa5lK48yzcFXXQoA', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\n +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json",
+      "time" : {
+        "start" : 1716272608243,
+        "stop" : 1716272608294,
+        "duration" : 51
+      }
+    }, {
+      "uid" : "4f1ef4a5b7fd035f",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '刷新token成功' == None\n +  where None = <built-in method get of dict object at 0x0000014F191B6B40>('message')\n +    where <built-in method get of dict object at 0x0000014F191B6B40> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwNH0.TOXPdeAD96XQ_Maa-ITQDDQZTnKhlW09esTDC6-C8_Wux9HSk3bWURoOvhmcidK-lCj4Tvw1ZO0dYFWGR8-lsg', 'userAttrs': {}, ...}.get\n +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwNH0.TOXPdeAD96XQ_Maa-ITQDDQZTnKhlW09esTDC6-C8_Wux9HSk3bWURoOvhmcidK-lCj4Tvw1ZO0dYFWGR8-lsg', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\n +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json",
+      "time" : {
+        "start" : 1716272606164,
+        "stop" : 1716272606215,
+        "duration" : 51
+      }
+    }, {
+      "uid" : "c2d850dec3954142",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '刷新token成功' == None\n +  where None = <built-in method get of dict object at 0x0000014F19157400>('message')\n +    where <built-in method get of dict object at 0x0000014F19157400> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwMn0.2ULfoTRcxys6pnuEKjHxZH4GI20D2qBisJFYoBn2GdZLw23Xapl1u2ATzI1w5cFlBcJf3_bFyVN7eo7OfOOMUg', 'userAttrs': {}, ...}.get\n +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwMn0.2ULfoTRcxys6pnuEKjHxZH4GI20D2qBisJFYoBn2GdZLw23Xapl1u2ATzI1w5cFlBcJf3_bFyVN7eo7OfOOMUg', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\n +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json",
+      "time" : {
+        "start" : 1716272604095,
+        "stop" : 1716272604145,
+        "duration" : 50
+      }
+    }, {
+      "uid" : "4cf6104851f97da",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '刷新token成功' == None\n +  where None = <built-in method get of dict object at 0x0000014F191A66C0>('message')\n +    where <built-in method get of dict object at 0x0000014F191A66C0> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwMH0.atAGdmkk-bhC9iAhggDWp0VlgVLl39hN3_u2ytWqmjm1GWT-vhDYRgCax56GrBuR6EkPJEseXgX-S8EfzoWXhg', 'userAttrs': {}, ...}.get\n +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwMH0.atAGdmkk-bhC9iAhggDWp0VlgVLl39hN3_u2ytWqmjm1GWT-vhDYRgCax56GrBuR6EkPJEseXgX-S8EfzoWXhg', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\n +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json",
+      "time" : {
+        "start" : 1716272602024,
+        "stop" : 1716272602074,
+        "duration" : 50
+      }
+    }, {
+      "uid" : "18d9dd9447f5bd7b",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '刷新token成功' == None\n +  where None = <built-in method get of dict object at 0x0000014F19124300>('message')\n +    where <built-in method get of dict object at 0x0000014F19124300> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjU5OH0.4JgpWuf9sSQnYV9dPIhf0I76OkCqUlLws0abjIB0nEM_iXrT2qd79jiUvk3kiwUvDIw9aHYQdvVjAFq8AQLNCw', 'userAttrs': {}, ...}.get\n +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjU5OH0.4JgpWuf9sSQnYV9dPIhf0I76OkCqUlLws0abjIB0nEM_iXrT2qd79jiUvk3kiwUvDIw9aHYQdvVjAFq8AQLNCw', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\n +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json",
+      "time" : {
+        "start" : 1716272599755,
+        "stop" : 1716272599845,
+        "duration" : 90
+      }
+    } ],
+    "categories" : [ {
+      "name" : "Product defects",
+      "matchedStatuses" : [ ],
+      "flaky" : false
+    } ],
+    "tags" : [ ]
+  },
+  "source" : "139913cc61e34bb9.json",
+  "parameterValues" : [ "'刷新token'", "None", "'中'", "'正向用例'", "{'message': '刷新token成功'}", "'GET'", "None", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/refresh'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/15e35cc79ee68b8c.json

+{
+  "uid" : "15e35cc79ee68b8c",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "e133082949e07d38e4a8587843153535",
+  "time" : {
+    "start" : 1716272621856,
+    "stop" : 1716272621912,
+    "duration" : 56
+  },
+  "status" : "passed",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "passed",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "9822ad938ab5e065",
+      "name" : "log",
+      "source" : "9822ad938ab5e065.txt",
+      "type" : "text/plain",
+      "size" : 376
+    }, {
+      "uid" : "756ecf2b72d113b2",
+      "name" : "stdout",
+      "source" : "756ecf2b72d113b2.txt",
+      "type" : "text/plain",
+      "size" : 7
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 2,
+    "shouldDisplayMessage" : false
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "组织管理"
+  }, {
+    "name" : "story",
+    "value" : "保存组织参数"
+  }, {
+    "name" : "severity",
+    "value" : "中"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'保存组织参数'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'query': {'orgCode': 'test_add_org'}, 'body': [{'alias': 'sz', 'value': 100}, {'alias': 'kc', 'value': '语文课'}]}"
+  }, {
+    "name" : "case_level",
+    "value" : "'中'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'state': True, 'message': '保存组织参数成功！', 'value': ''}"
+  }, {
+    "name" : "method",
+    "value" : "'post'"
+  }, {
+    "name" : "mime",
+    "value" : "'query|json'"
+  }, {
+    "name" : "module_name",
+    "value" : "'组织管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "None"
+  }, {
+    "name" : "sql_type",
+    "value" : "None"
+  }, {
+    "name" : "update_key",
+    "value" : "None"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/org/v1/orgParam/saveOrgParams'"
+  } ],
+  "links" : [ ],
+  "hidden" : false,
+  "retry" : false,
+  "extra" : {
+    "severity" : "normal",
+    "retries" : [ ],
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "15e35cc79ee68b8c.json",
+  "parameterValues" : [ "'保存组织参数'", "{'query': {'orgCode': 'test_add_org'}, 'body': [{'alias': 'sz', 'value': 100}, {'alias': 'kc', 'value': '语文课'}]}", "'中'", "'正向用例'", "{'state': True, 'message': '保存组织参数成功！', 'value': ''}", "'post'", "'query|json'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/orgParam/saveOrgParams'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/18d9dd9447f5bd7b.json

+{
+  "uid" : "18d9dd9447f5bd7b",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "1dcae5f805bddffd6ce19e14c8b3458b",
+  "time" : {
+    "start" : 1716272599755,
+    "stop" : 1716272599845,
+    "duration" : 90
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '刷新token成功' == None\n +  where None = <built-in method get of dict object at 0x0000014F19124300>('message')\n +    where <built-in method get of dict object at 0x0000014F19124300> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjU5OH0.4JgpWuf9sSQnYV9dPIhf0I76OkCqUlLws0abjIB0nEM_iXrT2qd79jiUvk3kiwUvDIw9aHYQdvVjAFq8AQLNCw', 'userAttrs': {}, ...}.get\n +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjU5OH0.4JgpWuf9sSQnYV9dPIhf0I76OkCqUlLws0abjIB0nEM_iXrT2qd79jiUvk3kiwUvDIw9aHYQdvVjAFq8AQLNCw', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\n +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '刷新token成功' == None\nE                +  where None = <built-in method get of dict object at 0x0000014F19124300>('message')\nE                +    where <built-in method get of dict object at 0x0000014F19124300> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjU5OH0.4JgpWuf9sSQnYV9dPIhf0I76OkCqUlLws0abjIB0nEM_iXrT2qd79jiUvk3kiwUvDIw9aHYQdvVjAFq8AQLNCw', 'userAttrs': {}, ...}.get\nE                +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjU5OH0.4JgpWuf9sSQnYV9dPIhf0I76OkCqUlLws0abjIB0nEM_iXrT2qd79jiUvk3kiwUvDIw9aHYQdvVjAFq8AQLNCw', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\nE                +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '刷新token成功' == None\n +  where None = <built-in method get of dict object at 0x0000014F19124300>('message')\n +    where <built-in method get of dict object at 0x0000014F19124300> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjU5OH0.4JgpWuf9sSQnYV9dPIhf0I76OkCqUlLws0abjIB0nEM_iXrT2qd79jiUvk3kiwUvDIw9aHYQdvVjAFq8AQLNCw', 'userAttrs': {}, ...}.get\n +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjU5OH0.4JgpWuf9sSQnYV9dPIhf0I76OkCqUlLws0abjIB0nEM_iXrT2qd79jiUvk3kiwUvDIw9aHYQdvVjAFq8AQLNCw', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\n +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '刷新token成功' == None\nE                +  where None = <built-in method get of dict object at 0x0000014F19124300>('message')\nE                +    where <built-in method get of dict object at 0x0000014F19124300> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjU5OH0.4JgpWuf9sSQnYV9dPIhf0I76OkCqUlLws0abjIB0nEM_iXrT2qd79jiUvk3kiwUvDIw9aHYQdvVjAFq8AQLNCw', 'userAttrs': {}, ...}.get\nE                +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjU5OH0.4JgpWuf9sSQnYV9dPIhf0I76OkCqUlLws0abjIB0nEM_iXrT2qd79jiUvk3kiwUvDIw9aHYQdvVjAFq8AQLNCw', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\nE                +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "3b913b49dc4f3472",
+      "name" : "log",
+      "source" : "3b913b49dc4f3472.txt",
+      "type" : "text/plain",
+      "size" : 439
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "认证接口"
+  }, {
+    "name" : "story",
+    "value" : "刷新token"
+  }, {
+    "name" : "severity",
+    "value" : "中"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'刷新token'"
+  }, {
+    "name" : "case_data",
+    "value" : "None"
+  }, {
+    "name" : "case_level",
+    "value" : "'中'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '刷新token成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'GET'"
+  }, {
+    "name" : "mime",
+    "value" : "None"
+  }, {
+    "name" : "module_name",
+    "value" : "'认证接口'"
+  }, {
+    "name" : "sql_data",
+    "value" : "None"
+  }, {
+    "name" : "sql_type",
+    "value" : "None"
+  }, {
+    "name" : "update_key",
+    "value" : "None"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/refresh'"
+  } ],
+  "links" : [ ],
+  "hidden" : true,
+  "retry" : true,
+  "extra" : {
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "18d9dd9447f5bd7b.json",
+  "parameterValues" : [ "'刷新token'", "None", "'中'", "'正向用例'", "{'message': '刷新token成功'}", "'GET'", "None", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/refresh'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/1ad3f99f8aec3b78.json

+{
+  "uid" : "1ad3f99f8aec3b78",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm",
+  "historyId" : "f0f670cbfec7a9680aec241c756307a6",
+  "time" : {
+    "start" : 1716272651358,
+    "stop" : 1716272651491,
+    "duration" : 133
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "aa23f63cb24a3b27",
+      "name" : "log",
+      "source" : "aa23f63cb24a3b27.txt",
+      "type" : "text/plain",
+      "size" : 980
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "维度管理"
+  }, {
+    "name" : "story",
+    "value" : "根据维度编码删除维度"
+  }, {
+    "name" : "severity",
+    "value" : "中"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-老张"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_mirZhang"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_mirZhang.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'根据维度编码删除维度'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'ids': '1792803475629817856'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'中'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '删除维度成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'DELETE'"
+  }, {
+    "name" : "mime",
+    "value" : "'query'"
+  }, {
+    "name" : "module_name",
+    "value" : "'维度管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"
+  }, {
+    "name" : "sql_type",
+    "value" : "'select'"
+  }, {
+    "name" : "update_key",
+    "value" : "'ids'"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'"
+  } ],
+  "links" : [ ],
+  "hidden" : true,
+  "retry" : true,
+  "extra" : {
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "1ad3f99f8aec3b78.json",
+  "parameterValues" : [ "'根据维度编码删除维度'", "{'ids': '1792803475629817856'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/1bd3c031f056ab2e.json

+{
+  "uid" : "1bd3c031f056ab2e",
+  "name" : "反向用例-用户名正确,密码为空",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "4164dfc118ea6cc8eeb9ce3984609436",
+  "time" : {
+    "start" : 1716272598829,
+    "stop" : 1716272598886,
+    "duration" : 57
+  },
+  "status" : "passed",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "passed",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "71a819440c253d52",
+      "name" : "log",
+      "source" : "71a819440c253d52.txt",
+      "type" : "text/plain",
+      "size" : 275
+    }, {
+      "uid" : "8883fd4feebc6905",
+      "name" : "stdout",
+      "source" : "8883fd4feebc6905.txt",
+      "type" : "text/plain",
+      "size" : 7
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 2,
+    "shouldDisplayMessage" : false
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "认证接口"
+  }, {
+    "name" : "story",
+    "value" : "登录系统"
+  }, {
+    "name" : "severity",
+    "value" : "中"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'登录系统'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'username': 'admin', 'password': ''}"
+  }, {
+    "name" : "case_level",
+    "value" : "'中'"
+  }, {
+    "name" : "case_title",
+    "value" : "'反向用例-用户名正确,密码为空'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '账号或密码错误'}"
+  }, {
+    "name" : "method",
+    "value" : "'POST'"
+  }, {
+    "name" : "mime",
+    "value" : "'application/json'"
+  }, {
+    "name" : "module_name",
+    "value" : "'认证接口'"
+  }, {
+    "name" : "sql_data",
+    "value" : "None"
+  }, {
+    "name" : "sql_type",
+    "value" : "None"
+  }, {
+    "name" : "update_key",
+    "value" : "None"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/auth'"
+  } ],
+  "links" : [ ],
+  "hidden" : false,
+  "retry" : false,
+  "extra" : {
+    "severity" : "normal",
+    "retries" : [ ],
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "1bd3c031f056ab2e.json",
+  "parameterValues" : [ "'登录系统'", "{'username': 'admin', 'password': ''}", "'中'", "'反向用例-用户名正确,密码为空'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/209ce81276c337a6.json

+{
+  "uid" : "209ce81276c337a6",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "487ae598a2b30a5ea2489bb3e5fa08a4",
+  "time" : {
+    "start" : 1716272614968,
+    "stop" : 1716272615147,
+    "duration" : 179
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "69ecbaba4125d9c7",
+      "name" : "log",
+      "source" : "69ecbaba4125d9c7.txt",
+      "type" : "text/plain",
+      "size" : 1193
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "组织管理"
+  }, {
+    "name" : "story",
+    "value" : "添加组织"
+  }, {
+    "name" : "severity",
+    "value" : "高"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'添加组织'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'高'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '添加组织成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'POST'"
+  }, {
+    "name" : "mime",
+    "value" : "'json'"
+  }, {
+    "name" : "module_name",
+    "value" : "'组织管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}"
+  }, {
+    "name" : "sql_type",
+    "value" : "'select|delete'"
+  }, {
+    "name" : "update_key",
+    "value" : "'demId'"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/org/v1/org/addOrg'"
+  } ],
+  "links" : [ ],
+  "hidden" : true,
+  "retry" : true,
+  "extra" : {
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "209ce81276c337a6.json",
+  "parameterValues" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/272c438f0bed80b.json

+{
+  "uid" : "272c438f0bed80b",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "1dcae5f805bddffd6ce19e14c8b3458b",
+  "time" : {
+    "start" : 1716272608243,
+    "stop" : 1716272608294,
+    "duration" : 51
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '刷新token成功' == None\n +  where None = <built-in method get of dict object at 0x0000014F19157380>('message')\n +    where <built-in method get of dict object at 0x0000014F19157380> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwNn0.W_ynWuu-79lzZS5ScuftmKzI8_B3z3llQ0gnSpahTsvIdUBKeaos4loXKk4DrzU4CGbchLTa5lK48yzcFXXQoA', 'userAttrs': {}, ...}.get\n +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwNn0.W_ynWuu-79lzZS5ScuftmKzI8_B3z3llQ0gnSpahTsvIdUBKeaos4loXKk4DrzU4CGbchLTa5lK48yzcFXXQoA', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\n +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '刷新token成功' == None\nE                +  where None = <built-in method get of dict object at 0x0000014F19157380>('message')\nE                +    where <built-in method get of dict object at 0x0000014F19157380> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwNn0.W_ynWuu-79lzZS5ScuftmKzI8_B3z3llQ0gnSpahTsvIdUBKeaos4loXKk4DrzU4CGbchLTa5lK48yzcFXXQoA', 'userAttrs': {}, ...}.get\nE                +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwNn0.W_ynWuu-79lzZS5ScuftmKzI8_B3z3llQ0gnSpahTsvIdUBKeaos4loXKk4DrzU4CGbchLTa5lK48yzcFXXQoA', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\nE                +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '刷新token成功' == None\n +  where None = <built-in method get of dict object at 0x0000014F19157380>('message')\n +    where <built-in method get of dict object at 0x0000014F19157380> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwNn0.W_ynWuu-79lzZS5ScuftmKzI8_B3z3llQ0gnSpahTsvIdUBKeaos4loXKk4DrzU4CGbchLTa5lK48yzcFXXQoA', 'userAttrs': {}, ...}.get\n +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwNn0.W_ynWuu-79lzZS5ScuftmKzI8_B3z3llQ0gnSpahTsvIdUBKeaos4loXKk4DrzU4CGbchLTa5lK48yzcFXXQoA', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\n +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '刷新token成功' == None\nE                +  where None = <built-in method get of dict object at 0x0000014F19157380>('message')\nE                +    where <built-in method get of dict object at 0x0000014F19157380> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwNn0.W_ynWuu-79lzZS5ScuftmKzI8_B3z3llQ0gnSpahTsvIdUBKeaos4loXKk4DrzU4CGbchLTa5lK48yzcFXXQoA', 'userAttrs': {}, ...}.get\nE                +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwNn0.W_ynWuu-79lzZS5ScuftmKzI8_B3z3llQ0gnSpahTsvIdUBKeaos4loXKk4DrzU4CGbchLTa5lK48yzcFXXQoA', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\nE                +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "39baf5c12bf79df8",
+      "name" : "log",
+      "source" : "39baf5c12bf79df8.txt",
+      "type" : "text/plain",
+      "size" : 2199
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "认证接口"
+  }, {
+    "name" : "story",
+    "value" : "刷新token"
+  }, {
+    "name" : "severity",
+    "value" : "中"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'刷新token'"
+  }, {
+    "name" : "case_data",
+    "value" : "None"
+  }, {
+    "name" : "case_level",
+    "value" : "'中'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '刷新token成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'GET'"
+  }, {
+    "name" : "mime",
+    "value" : "None"
+  }, {
+    "name" : "module_name",
+    "value" : "'认证接口'"
+  }, {
+    "name" : "sql_data",
+    "value" : "None"
+  }, {
+    "name" : "sql_type",
+    "value" : "None"
+  }, {
+    "name" : "update_key",
+    "value" : "None"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/refresh'"
+  } ],
+  "links" : [ ],
+  "hidden" : true,
+  "retry" : true,
+  "extra" : {
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "272c438f0bed80b.json",
+  "parameterValues" : [ "'刷新token'", "None", "'中'", "'正向用例'", "{'message': '刷新token成功'}", "'GET'", "None", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/refresh'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/3015128a124f9ae6.json

+{
+  "uid" : "3015128a124f9ae6",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm",
+  "historyId" : "526f1fd519b78b4955668d6cfd277048",
+  "time" : {
+    "start" : 1716272640167,
+    "stop" : 1716272640342,
+    "duration" : 175
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "7cd371d730635a5c",
+      "name" : "log",
+      "source" : "7cd371d730635a5c.txt",
+      "type" : "text/plain",
+      "size" : 1591
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "组织管理"
+  }, {
+    "name" : "story",
+    "value" : "添加组织"
+  }, {
+    "name" : "severity",
+    "value" : "高"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-老张"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_mirZhang"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_mirZhang.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'添加组织'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'高'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '添加组织成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'POST'"
+  }, {
+    "name" : "mime",
+    "value" : "'json'"
+  }, {
+    "name" : "module_name",
+    "value" : "'组织管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}"
+  }, {
+    "name" : "sql_type",
+    "value" : "'select|delete'"
+  }, {
+    "name" : "update_key",
+    "value" : "'demId'"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/org/v1/org/addOrg'"
+  } ],
+  "links" : [ ],
+  "hidden" : true,
+  "retry" : true,
+  "extra" : {
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "3015128a124f9ae6.json",
+  "parameterValues" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/34d4a7d4229ac13b.json

+{
+  "uid" : "34d4a7d4229ac13b",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm",
+  "historyId" : "f0f670cbfec7a9680aec241c756307a6",
+  "time" : {
+    "start" : 1716272644958,
+    "stop" : 1716272645054,
+    "duration" : 96
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '删除维度成功' == '删除维度成功！'\n  \n  - 删除维度成功！\n  ?       -\n  + 删除维度成功",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == '删除维度成功！'\nE                 \nE                 - 删除维度成功！\nE                 ?       -\nE                 + 删除维度成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '删除维度成功' == '删除维度成功！'\n  \n  - 删除维度成功！\n  ?       -\n  + 删除维度成功",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == '删除维度成功！'\nE                 \nE                 - 删除维度成功！\nE                 ?       -\nE                 + 删除维度成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "a8ff188565383ebb",
+      "name" : "log",
+      "source" : "a8ff188565383ebb.txt",
+      "type" : "text/plain",
+      "size" : 245
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "维度管理"
+  }, {
+    "name" : "story",
+    "value" : "根据维度编码删除维度"
+  }, {
+    "name" : "severity",
+    "value" : "中"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-老张"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_mirZhang"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_mirZhang.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'根据维度编码删除维度'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'ids': '需要更新'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'中'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '删除维度成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'DELETE'"
+  }, {
+    "name" : "mime",
+    "value" : "'query'"
+  }, {
+    "name" : "module_name",
+    "value" : "'维度管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"
+  }, {
+    "name" : "sql_type",
+    "value" : "'select'"
+  }, {
+    "name" : "update_key",
+    "value" : "'ids'"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'"
+  } ],
+  "links" : [ ],
+  "hidden" : true,
+  "retry" : true,
+  "extra" : {
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "34d4a7d4229ac13b.json",
+  "parameterValues" : [ "'根据维度编码删除维度'", "{'ids': '需要更新'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/47066bd5655ab306.json

+{
+  "uid" : "47066bd5655ab306",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "487ae598a2b30a5ea2489bb3e5fa08a4",
+  "time" : {
+    "start" : 1716272612750,
+    "stop" : 1716272612931,
+    "duration" : 181
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "f32a4201d93ebd55",
+      "name" : "log",
+      "source" : "f32a4201d93ebd55.txt",
+      "type" : "text/plain",
+      "size" : 795
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "组织管理"
+  }, {
+    "name" : "story",
+    "value" : "添加组织"
+  }, {
+    "name" : "severity",
+    "value" : "高"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'添加组织'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'高'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '添加组织成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'POST'"
+  }, {
+    "name" : "mime",
+    "value" : "'json'"
+  }, {
+    "name" : "module_name",
+    "value" : "'组织管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}"
+  }, {
+    "name" : "sql_type",
+    "value" : "'select|delete'"
+  }, {
+    "name" : "update_key",
+    "value" : "'demId'"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/org/v1/org/addOrg'"
+  } ],
+  "links" : [ ],
+  "hidden" : true,
+  "retry" : true,
+  "extra" : {
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "47066bd5655ab306.json",
+  "parameterValues" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/4cf6104851f97da.json

+{
+  "uid" : "4cf6104851f97da",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "1dcae5f805bddffd6ce19e14c8b3458b",
+  "time" : {
+    "start" : 1716272602024,
+    "stop" : 1716272602074,
+    "duration" : 50
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '刷新token成功' == None\n +  where None = <built-in method get of dict object at 0x0000014F191A66C0>('message')\n +    where <built-in method get of dict object at 0x0000014F191A66C0> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwMH0.atAGdmkk-bhC9iAhggDWp0VlgVLl39hN3_u2ytWqmjm1GWT-vhDYRgCax56GrBuR6EkPJEseXgX-S8EfzoWXhg', 'userAttrs': {}, ...}.get\n +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwMH0.atAGdmkk-bhC9iAhggDWp0VlgVLl39hN3_u2ytWqmjm1GWT-vhDYRgCax56GrBuR6EkPJEseXgX-S8EfzoWXhg', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\n +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '刷新token成功' == None\nE                +  where None = <built-in method get of dict object at 0x0000014F191A66C0>('message')\nE                +    where <built-in method get of dict object at 0x0000014F191A66C0> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwMH0.atAGdmkk-bhC9iAhggDWp0VlgVLl39hN3_u2ytWqmjm1GWT-vhDYRgCax56GrBuR6EkPJEseXgX-S8EfzoWXhg', 'userAttrs': {}, ...}.get\nE                +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwMH0.atAGdmkk-bhC9iAhggDWp0VlgVLl39hN3_u2ytWqmjm1GWT-vhDYRgCax56GrBuR6EkPJEseXgX-S8EfzoWXhg', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\nE                +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '刷新token成功' == None\n +  where None = <built-in method get of dict object at 0x0000014F191A66C0>('message')\n +    where <built-in method get of dict object at 0x0000014F191A66C0> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwMH0.atAGdmkk-bhC9iAhggDWp0VlgVLl39hN3_u2ytWqmjm1GWT-vhDYRgCax56GrBuR6EkPJEseXgX-S8EfzoWXhg', 'userAttrs': {}, ...}.get\n +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwMH0.atAGdmkk-bhC9iAhggDWp0VlgVLl39hN3_u2ytWqmjm1GWT-vhDYRgCax56GrBuR6EkPJEseXgX-S8EfzoWXhg', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\n +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '刷新token成功' == None\nE                +  where None = <built-in method get of dict object at 0x0000014F191A66C0>('message')\nE                +    where <built-in method get of dict object at 0x0000014F191A66C0> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwMH0.atAGdmkk-bhC9iAhggDWp0VlgVLl39hN3_u2ytWqmjm1GWT-vhDYRgCax56GrBuR6EkPJEseXgX-S8EfzoWXhg', 'userAttrs': {}, ...}.get\nE                +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwMH0.atAGdmkk-bhC9iAhggDWp0VlgVLl39hN3_u2ytWqmjm1GWT-vhDYRgCax56GrBuR6EkPJEseXgX-S8EfzoWXhg', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\nE                +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "95802db4a485e5cb",
+      "name" : "log",
+      "source" : "95802db4a485e5cb.txt",
+      "type" : "text/plain",
+      "size" : 879
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "认证接口"
+  }, {
+    "name" : "story",
+    "value" : "刷新token"
+  }, {
+    "name" : "severity",
+    "value" : "中"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'刷新token'"
+  }, {
+    "name" : "case_data",
+    "value" : "None"
+  }, {
+    "name" : "case_level",
+    "value" : "'中'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '刷新token成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'GET'"
+  }, {
+    "name" : "mime",
+    "value" : "None"
+  }, {
+    "name" : "module_name",
+    "value" : "'认证接口'"
+  }, {
+    "name" : "sql_data",
+    "value" : "None"
+  }, {
+    "name" : "sql_type",
+    "value" : "None"
+  }, {
+    "name" : "update_key",
+    "value" : "None"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/refresh'"
+  } ],
+  "links" : [ ],
+  "hidden" : true,
+  "retry" : true,
+  "extra" : {
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "4cf6104851f97da.json",
+  "parameterValues" : [ "'刷新token'", "None", "'中'", "'正向用例'", "{'message': '刷新token成功'}", "'GET'", "None", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/refresh'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/4f1ef4a5b7fd035f.json

+{
+  "uid" : "4f1ef4a5b7fd035f",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "1dcae5f805bddffd6ce19e14c8b3458b",
+  "time" : {
+    "start" : 1716272606164,
+    "stop" : 1716272606215,
+    "duration" : 51
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '刷新token成功' == None\n +  where None = <built-in method get of dict object at 0x0000014F191B6B40>('message')\n +    where <built-in method get of dict object at 0x0000014F191B6B40> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwNH0.TOXPdeAD96XQ_Maa-ITQDDQZTnKhlW09esTDC6-C8_Wux9HSk3bWURoOvhmcidK-lCj4Tvw1ZO0dYFWGR8-lsg', 'userAttrs': {}, ...}.get\n +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwNH0.TOXPdeAD96XQ_Maa-ITQDDQZTnKhlW09esTDC6-C8_Wux9HSk3bWURoOvhmcidK-lCj4Tvw1ZO0dYFWGR8-lsg', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\n +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '刷新token成功' == None\nE                +  where None = <built-in method get of dict object at 0x0000014F191B6B40>('message')\nE                +    where <built-in method get of dict object at 0x0000014F191B6B40> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwNH0.TOXPdeAD96XQ_Maa-ITQDDQZTnKhlW09esTDC6-C8_Wux9HSk3bWURoOvhmcidK-lCj4Tvw1ZO0dYFWGR8-lsg', 'userAttrs': {}, ...}.get\nE                +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwNH0.TOXPdeAD96XQ_Maa-ITQDDQZTnKhlW09esTDC6-C8_Wux9HSk3bWURoOvhmcidK-lCj4Tvw1ZO0dYFWGR8-lsg', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\nE                +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '刷新token成功' == None\n +  where None = <built-in method get of dict object at 0x0000014F191B6B40>('message')\n +    where <built-in method get of dict object at 0x0000014F191B6B40> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwNH0.TOXPdeAD96XQ_Maa-ITQDDQZTnKhlW09esTDC6-C8_Wux9HSk3bWURoOvhmcidK-lCj4Tvw1ZO0dYFWGR8-lsg', 'userAttrs': {}, ...}.get\n +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwNH0.TOXPdeAD96XQ_Maa-ITQDDQZTnKhlW09esTDC6-C8_Wux9HSk3bWURoOvhmcidK-lCj4Tvw1ZO0dYFWGR8-lsg', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\n +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '刷新token成功' == None\nE                +  where None = <built-in method get of dict object at 0x0000014F191B6B40>('message')\nE                +    where <built-in method get of dict object at 0x0000014F191B6B40> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwNH0.TOXPdeAD96XQ_Maa-ITQDDQZTnKhlW09esTDC6-C8_Wux9HSk3bWURoOvhmcidK-lCj4Tvw1ZO0dYFWGR8-lsg', 'userAttrs': {}, ...}.get\nE                +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwNH0.TOXPdeAD96XQ_Maa-ITQDDQZTnKhlW09esTDC6-C8_Wux9HSk3bWURoOvhmcidK-lCj4Tvw1ZO0dYFWGR8-lsg', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\nE                +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "8b75f965076bf807",
+      "name" : "log",
+      "source" : "8b75f965076bf807.txt",
+      "type" : "text/plain",
+      "size" : 1759
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "认证接口"
+  }, {
+    "name" : "story",
+    "value" : "刷新token"
+  }, {
+    "name" : "severity",
+    "value" : "中"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'刷新token'"
+  }, {
+    "name" : "case_data",
+    "value" : "None"
+  }, {
+    "name" : "case_level",
+    "value" : "'中'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '刷新token成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'GET'"
+  }, {
+    "name" : "mime",
+    "value" : "None"
+  }, {
+    "name" : "module_name",
+    "value" : "'认证接口'"
+  }, {
+    "name" : "sql_data",
+    "value" : "None"
+  }, {
+    "name" : "sql_type",
+    "value" : "None"
+  }, {
+    "name" : "update_key",
+    "value" : "None"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/refresh'"
+  } ],
+  "links" : [ ],
+  "hidden" : true,
+  "retry" : true,
+  "extra" : {
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "4f1ef4a5b7fd035f.json",
+  "parameterValues" : [ "'刷新token'", "None", "'中'", "'正向用例'", "{'message': '刷新token成功'}", "'GET'", "None", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/refresh'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/510c89b87f6352b8.json

+{
+  "uid" : "510c89b87f6352b8",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm",
+  "historyId" : "aab084bf6a05ec45b335f51ecc264b7e",
+  "time" : {
+    "start" : 1716272633398,
+    "stop" : 1716272633535,
+    "duration" : 137
+  },
+  "status" : "passed",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "passed",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "f01d7cb12097c711",
+      "name" : "log",
+      "source" : "f01d7cb12097c711.txt",
+      "type" : "text/plain",
+      "size" : 340
+    }, {
+      "uid" : "f6d07ad08c02221c",
+      "name" : "stdout",
+      "source" : "f6d07ad08c02221c.txt",
+      "type" : "text/plain",
+      "size" : 7
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 2,
+    "shouldDisplayMessage" : false
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "维度管理"
+  }, {
+    "name" : "story",
+    "value" : "添加维度"
+  }, {
+    "name" : "severity",
+    "value" : "高"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-老张"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_mirZhang"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_mirZhang.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'添加维度'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'code': 'api_auto_test_add_dem', 'description': 'api_auto_test_add_dem', 'isDefault': 0, 'name': 'api_auto_test_add_dem'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'高'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '添加维度成功！'}"
+  }, {
+    "name" : "method",
+    "value" : "'pOst'"
+  }, {
+    "name" : "mime",
+    "value" : "'json'"
+  }, {
+    "name" : "module_name",
+    "value" : "'维度管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "'delete FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"
+  }, {
+    "name" : "sql_type",
+    "value" : "'delete'"
+  }, {
+    "name" : "update_key",
+    "value" : "None"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/demension/v1/dem/addDem'"
+  } ],
+  "links" : [ ],
+  "hidden" : false,
+  "retry" : false,
+  "extra" : {
+    "severity" : "normal",
+    "retries" : [ ],
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "510c89b87f6352b8.json",
+  "parameterValues" : [ "'添加维度'", "{'code': 'api_auto_test_add_dem', 'description': 'api_auto_test_add_dem', 'isDefault': 0, 'name': 'api_auto_test_add_dem'}", "'高'", "'正向用例'", "{'message': '添加维度成功！'}", "'pOst'", "'json'", "'维度管理'", "'delete FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'delete'", "None", "'http://120.46.172.186:8080/api/demension/v1/dem/addDem'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/5532c9175fb2354e.json

+{
+  "uid" : "5532c9175fb2354e",
+  "name" : "反向用例-密码正确,用户名为空",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "ca39ba3d830745ef2c54de45a0fd94de",
+  "time" : {
+    "start" : 1716272599213,
+    "stop" : 1716272599306,
+    "duration" : 93
+  },
+  "status" : "passed",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "passed",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "538dd3c6269d607b",
+      "name" : "log",
+      "source" : "538dd3c6269d607b.txt",
+      "type" : "text/plain",
+      "size" : 278
+    }, {
+      "uid" : "8c5282cbec7e86da",
+      "name" : "stdout",
+      "source" : "8c5282cbec7e86da.txt",
+      "type" : "text/plain",
+      "size" : 7
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 2,
+    "shouldDisplayMessage" : false
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "认证接口"
+  }, {
+    "name" : "story",
+    "value" : "登录系统"
+  }, {
+    "name" : "severity",
+    "value" : "中"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'登录系统'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'username': '', 'password': 'MTIzNDU2'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'中'"
+  }, {
+    "name" : "case_title",
+    "value" : "'反向用例-密码正确,用户名为空'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '账号或密码错误'}"
+  }, {
+    "name" : "method",
+    "value" : "'POST'"
+  }, {
+    "name" : "mime",
+    "value" : "'application/json'"
+  }, {
+    "name" : "module_name",
+    "value" : "'认证接口'"
+  }, {
+    "name" : "sql_data",
+    "value" : "None"
+  }, {
+    "name" : "sql_type",
+    "value" : "None"
+  }, {
+    "name" : "update_key",
+    "value" : "None"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/auth'"
+  } ],
+  "links" : [ ],
+  "hidden" : false,
+  "retry" : false,
+  "extra" : {
+    "severity" : "normal",
+    "retries" : [ ],
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "5532c9175fb2354e.json",
+  "parameterValues" : [ "'登录系统'", "{'username': '', 'password': 'MTIzNDU2'}", "'中'", "'反向用例-密码正确,用户名为空'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/5b0b595f880fe013.json

+{
+  "uid" : "5b0b595f880fe013",
+  "name" : "反向用例-密码正确,用户名为特殊字符",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "fa305c7b3d900250c6115572baa5540a",
+  "time" : {
+    "start" : 1716272599527,
+    "stop" : 1716272599627,
+    "duration" : 100
+  },
+  "status" : "passed",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "passed",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "7cf883af7fabeddf",
+      "name" : "log",
+      "source" : "7cf883af7fabeddf.txt",
+      "type" : "text/plain",
+      "size" : 290
+    }, {
+      "uid" : "c40a6c404248f2af",
+      "name" : "stdout",
+      "source" : "c40a6c404248f2af.txt",
+      "type" : "text/plain",
+      "size" : 7
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 2,
+    "shouldDisplayMessage" : false
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "认证接口"
+  }, {
+    "name" : "story",
+    "value" : "登录系统"
+  }, {
+    "name" : "severity",
+    "value" : "中"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'登录系统'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'username': '☯㍿卍卐', 'password': 'MTIzNDU2'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'中'"
+  }, {
+    "name" : "case_title",
+    "value" : "'反向用例-密码正确,用户名为特殊字符'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '账号或密码错误'}"
+  }, {
+    "name" : "method",
+    "value" : "'POST'"
+  }, {
+    "name" : "mime",
+    "value" : "'json'"
+  }, {
+    "name" : "module_name",
+    "value" : "'认证接口'"
+  }, {
+    "name" : "sql_data",
+    "value" : "None"
+  }, {
+    "name" : "sql_type",
+    "value" : "None"
+  }, {
+    "name" : "update_key",
+    "value" : "None"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/auth'"
+  } ],
+  "links" : [ ],
+  "hidden" : false,
+  "retry" : false,
+  "extra" : {
+    "severity" : "normal",
+    "retries" : [ ],
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "5b0b595f880fe013.json",
+  "parameterValues" : [ "'登录系统'", "{'username': '☯㍿卍卐', 'password': 'MTIzNDU2'}", "'中'", "'反向用例-密码正确,用户名为特殊字符'", "{'message': '账号或密码错误'}", "'POST'", "'json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/5dd7bd33a0896cb1.json

+{
+  "uid" : "5dd7bd33a0896cb1",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm",
+  "historyId" : "f0f670cbfec7a9680aec241c756307a6",
+  "time" : {
+    "start" : 1716272653523,
+    "stop" : 1716272653661,
+    "duration" : 138
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "116a66ad8e750f6d",
+      "name" : "log",
+      "source" : "116a66ad8e750f6d.txt",
+      "type" : "text/plain",
+      "size" : 1225
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "维度管理"
+  }, {
+    "name" : "story",
+    "value" : "根据维度编码删除维度"
+  }, {
+    "name" : "severity",
+    "value" : "中"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-老张"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_mirZhang"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_mirZhang.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'根据维度编码删除维度'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'ids': '1792803475629817856'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'中'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '删除维度成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'DELETE'"
+  }, {
+    "name" : "mime",
+    "value" : "'query'"
+  }, {
+    "name" : "module_name",
+    "value" : "'维度管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"
+  }, {
+    "name" : "sql_type",
+    "value" : "'select'"
+  }, {
+    "name" : "update_key",
+    "value" : "'ids'"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'"
+  } ],
+  "links" : [ ],
+  "hidden" : true,
+  "retry" : true,
+  "extra" : {
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "5dd7bd33a0896cb1.json",
+  "parameterValues" : [ "'根据维度编码删除维度'", "{'ids': '1792803475629817856'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/63fd0603d3fc3e68.json

+{
+  "uid" : "63fd0603d3fc3e68",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm",
+  "historyId" : "f0f670cbfec7a9680aec241c756307a6",
+  "time" : {
+    "start" : 1716272647081,
+    "stop" : 1716272647173,
+    "duration" : 92
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "6666807bee4dd972",
+      "name" : "log",
+      "source" : "6666807bee4dd972.txt",
+      "type" : "text/plain",
+      "size" : 490
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "维度管理"
+  }, {
+    "name" : "story",
+    "value" : "根据维度编码删除维度"
+  }, {
+    "name" : "severity",
+    "value" : "中"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-老张"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_mirZhang"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_mirZhang.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'根据维度编码删除维度'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'ids': '1792803475629817856'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'中'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '删除维度成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'DELETE'"
+  }, {
+    "name" : "mime",
+    "value" : "'query'"
+  }, {
+    "name" : "module_name",
+    "value" : "'维度管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"
+  }, {
+    "name" : "sql_type",
+    "value" : "'select'"
+  }, {
+    "name" : "update_key",
+    "value" : "'ids'"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'"
+  } ],
+  "links" : [ ],
+  "hidden" : true,
+  "retry" : true,
+  "extra" : {
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "63fd0603d3fc3e68.json",
+  "parameterValues" : [ "'根据维度编码删除维度'", "{'ids': '1792803475629817856'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/643ca7629b09152b.json

+{
+  "uid" : "643ca7629b09152b",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm",
+  "historyId" : "526f1fd519b78b4955668d6cfd277048",
+  "time" : {
+    "start" : 1716272644557,
+    "stop" : 1716272644742,
+    "duration" : 185
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "6b95a89eb4116b8d",
+      "name" : "log",
+      "source" : "6b95a89eb4116b8d.txt",
+      "type" : "text/plain",
+      "size" : 2387
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "组织管理"
+  }, {
+    "name" : "story",
+    "value" : "添加组织"
+  }, {
+    "name" : "severity",
+    "value" : "高"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-老张"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_mirZhang"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_mirZhang.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'添加组织'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'高'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '添加组织成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'POST'"
+  }, {
+    "name" : "mime",
+    "value" : "'json'"
+  }, {
+    "name" : "module_name",
+    "value" : "'组织管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}"
+  }, {
+    "name" : "sql_type",
+    "value" : "'select|delete'"
+  }, {
+    "name" : "update_key",
+    "value" : "'demId'"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/org/v1/org/addOrg'"
+  } ],
+  "links" : [ ],
+  "hidden" : false,
+  "retry" : false,
+  "extra" : {
+    "severity" : "normal",
+    "retries" : [ {
+      "uid" : "f0b29a97131b512d",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+      "time" : {
+        "start" : 1716272642365,
+        "stop" : 1716272642541,
+        "duration" : 176
+      }
+    }, {
+      "uid" : "3015128a124f9ae6",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+      "time" : {
+        "start" : 1716272640167,
+        "stop" : 1716272640342,
+        "duration" : 175
+      }
+    }, {
+      "uid" : "bab371eff6794f2b",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+      "time" : {
+        "start" : 1716272637956,
+        "stop" : 1716272638139,
+        "duration" : 183
+      }
+    }, {
+      "uid" : "d86d7ab21b67c470",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+      "time" : {
+        "start" : 1716272635752,
+        "stop" : 1716272635930,
+        "duration" : 178
+      }
+    }, {
+      "uid" : "d386a81c173e63a4",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+      "time" : {
+        "start" : 1716272633544,
+        "stop" : 1716272633720,
+        "duration" : 176
+      }
+    } ],
+    "categories" : [ {
+      "name" : "Product defects",
+      "matchedStatuses" : [ ],
+      "flaky" : false
+    } ],
+    "tags" : [ ]
+  },
+  "source" : "643ca7629b09152b.json",
+  "parameterValues" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/64c7a0a97adde6d1.json

+{
+  "uid" : "64c7a0a97adde6d1",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "347d2f73ed73495ba7ba72dbf723f253",
+  "time" : {
+    "start" : 1716272630526,
+    "stop" : 1716272630660,
+    "duration" : 134
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "1cc5cc26b0e6793e",
+      "name" : "log",
+      "source" : "1cc5cc26b0e6793e.txt",
+      "type" : "text/plain",
+      "size" : 1225
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "维度管理"
+  }, {
+    "name" : "story",
+    "value" : "根据维度编码删除维度"
+  }, {
+    "name" : "severity",
+    "value" : "中"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'根据维度编码删除维度'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'ids': '1792803379156631552'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'中'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '删除维度成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'DELETE'"
+  }, {
+    "name" : "mime",
+    "value" : "'query'"
+  }, {
+    "name" : "module_name",
+    "value" : "'维度管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"
+  }, {
+    "name" : "sql_type",
+    "value" : "'select'"
+  }, {
+    "name" : "update_key",
+    "value" : "'ids'"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'"
+  } ],
+  "links" : [ ],
+  "hidden" : true,
+  "retry" : true,
+  "extra" : {
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "64c7a0a97adde6d1.json",
+  "parameterValues" : [ "'根据维度编码删除维度'", "{'ids': '1792803379156631552'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/682b7b7636aca843.json

+{
+  "uid" : "682b7b7636aca843",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "487ae598a2b30a5ea2489bb3e5fa08a4",
+  "time" : {
+    "start" : 1716272610542,
+    "stop" : 1716272610722,
+    "duration" : 180
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "de31b21afa53e092",
+      "name" : "log",
+      "source" : "de31b21afa53e092.txt",
+      "type" : "text/plain",
+      "size" : 397
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "组织管理"
+  }, {
+    "name" : "story",
+    "value" : "添加组织"
+  }, {
+    "name" : "severity",
+    "value" : "高"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'添加组织'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'code': 'test_add_org', 'demId': '需要更新', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'高'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '添加组织成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'POST'"
+  }, {
+    "name" : "mime",
+    "value" : "'json'"
+  }, {
+    "name" : "module_name",
+    "value" : "'组织管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}"
+  }, {
+    "name" : "sql_type",
+    "value" : "'select|delete'"
+  }, {
+    "name" : "update_key",
+    "value" : "'demId'"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/org/v1/org/addOrg'"
+  } ],
+  "links" : [ ],
+  "hidden" : true,
+  "retry" : true,
+  "extra" : {
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "682b7b7636aca843.json",
+  "parameterValues" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '需要更新', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/6bce7862e8bf2a3f.json

+{
+  "uid" : "6bce7862e8bf2a3f",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm",
+  "historyId" : "f0f670cbfec7a9680aec241c756307a6",
+  "time" : {
+    "start" : 1716272655685,
+    "stop" : 1716272655817,
+    "duration" : 132
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "3ee4fb5ea7f92b8a",
+      "name" : "log",
+      "source" : "3ee4fb5ea7f92b8a.txt",
+      "type" : "text/plain",
+      "size" : 1470
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "维度管理"
+  }, {
+    "name" : "story",
+    "value" : "根据维度编码删除维度"
+  }, {
+    "name" : "severity",
+    "value" : "中"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-老张"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_mirZhang"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_mirZhang.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'根据维度编码删除维度'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'ids': '1792803475629817856'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'中'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '删除维度成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'DELETE'"
+  }, {
+    "name" : "mime",
+    "value" : "'query'"
+  }, {
+    "name" : "module_name",
+    "value" : "'维度管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"
+  }, {
+    "name" : "sql_type",
+    "value" : "'select'"
+  }, {
+    "name" : "update_key",
+    "value" : "'ids'"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'"
+  } ],
+  "links" : [ ],
+  "hidden" : false,
+  "retry" : false,
+  "extra" : {
+    "severity" : "normal",
+    "retries" : [ {
+      "uid" : "5dd7bd33a0896cb1",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+      "time" : {
+        "start" : 1716272653523,
+        "stop" : 1716272653661,
+        "duration" : 138
+      }
+    }, {
+      "uid" : "1ad3f99f8aec3b78",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+      "time" : {
+        "start" : 1716272651358,
+        "stop" : 1716272651491,
+        "duration" : 133
+      }
+    }, {
+      "uid" : "12eaadd487a58cd",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+      "time" : {
+        "start" : 1716272649197,
+        "stop" : 1716272649328,
+        "duration" : 131
+      }
+    }, {
+      "uid" : "63fd0603d3fc3e68",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+      "time" : {
+        "start" : 1716272647081,
+        "stop" : 1716272647173,
+        "duration" : 92
+      }
+    }, {
+      "uid" : "34d4a7d4229ac13b",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '删除维度成功' == '删除维度成功！'\n  \n  - 删除维度成功！\n  ?       -\n  + 删除维度成功",
+      "time" : {
+        "start" : 1716272644958,
+        "stop" : 1716272645054,
+        "duration" : 96
+      }
+    } ],
+    "categories" : [ {
+      "name" : "Product defects",
+      "matchedStatuses" : [ ],
+      "flaky" : false
+    } ],
+    "tags" : [ ]
+  },
+  "source" : "6bce7862e8bf2a3f.json",
+  "parameterValues" : [ "'根据维度编码删除维度'", "{'ids': '1792803475629817856'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/76ee0be7403e029e.json

+{
+  "uid" : "76ee0be7403e029e",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm",
+  "historyId" : "f523c6add46569d79b9a33cc763be891",
+  "time" : {
+    "start" : 1716272644818,
+    "stop" : 1716272644873,
+    "duration" : 55
+  },
+  "status" : "passed",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "passed",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "5beb8dd75024124b",
+      "name" : "log",
+      "source" : "5beb8dd75024124b.txt",
+      "type" : "text/plain",
+      "size" : 376
+    }, {
+      "uid" : "4a87a856d252348a",
+      "name" : "stdout",
+      "source" : "4a87a856d252348a.txt",
+      "type" : "text/plain",
+      "size" : 7
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 2,
+    "shouldDisplayMessage" : false
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "组织管理"
+  }, {
+    "name" : "story",
+    "value" : "保存组织参数"
+  }, {
+    "name" : "severity",
+    "value" : "中"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-老张"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_mirZhang"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_mirZhang.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'保存组织参数'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'query': {'orgCode': 'test_add_org'}, 'body': [{'alias': 'sz', 'value': 100}, {'alias': 'kc', 'value': '语文课'}]}"
+  }, {
+    "name" : "case_level",
+    "value" : "'中'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'state': True, 'message': '保存组织参数成功！', 'value': ''}"
+  }, {
+    "name" : "method",
+    "value" : "'post'"
+  }, {
+    "name" : "mime",
+    "value" : "'query|json'"
+  }, {
+    "name" : "module_name",
+    "value" : "'组织管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "None"
+  }, {
+    "name" : "sql_type",
+    "value" : "None"
+  }, {
+    "name" : "update_key",
+    "value" : "None"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/org/v1/orgParam/saveOrgParams'"
+  } ],
+  "links" : [ ],
+  "hidden" : false,
+  "retry" : false,
+  "extra" : {
+    "severity" : "normal",
+    "retries" : [ ],
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "76ee0be7403e029e.json",
+  "parameterValues" : [ "'保存组织参数'", "{'query': {'orgCode': 'test_add_org'}, 'body': [{'alias': 'sz', 'value': 100}, {'alias': 'kc', 'value': '语文课'}]}", "'中'", "'正向用例'", "{'state': True, 'message': '保存组织参数成功！', 'value': ''}", "'post'", "'query|json'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/orgParam/saveOrgParams'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/7af172a2303b627d.json

+{
+  "uid" : "7af172a2303b627d",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "435ba53246b35b4af7286c32ad75fe23",
+  "time" : {
+    "start" : 1716272610398,
+    "stop" : 1716272610534,
+    "duration" : 136
+  },
+  "status" : "passed",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "passed",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "bbc2176bbcbfcb7e",
+      "name" : "log",
+      "source" : "bbc2176bbcbfcb7e.txt",
+      "type" : "text/plain",
+      "size" : 340
+    }, {
+      "uid" : "2ffbcb889e2046d8",
+      "name" : "stdout",
+      "source" : "2ffbcb889e2046d8.txt",
+      "type" : "text/plain",
+      "size" : 7
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 2,
+    "shouldDisplayMessage" : false
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "维度管理"
+  }, {
+    "name" : "story",
+    "value" : "添加维度"
+  }, {
+    "name" : "severity",
+    "value" : "高"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'添加维度'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'code': 'api_auto_test_add_dem', 'description': 'api_auto_test_add_dem', 'isDefault': 0, 'name': 'api_auto_test_add_dem'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'高'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '添加维度成功！'}"
+  }, {
+    "name" : "method",
+    "value" : "'pOst'"
+  }, {
+    "name" : "mime",
+    "value" : "'json'"
+  }, {
+    "name" : "module_name",
+    "value" : "'维度管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "'delete FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"
+  }, {
+    "name" : "sql_type",
+    "value" : "'delete'"
+  }, {
+    "name" : "update_key",
+    "value" : "None"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/demension/v1/dem/addDem'"
+  } ],
+  "links" : [ ],
+  "hidden" : false,
+  "retry" : false,
+  "extra" : {
+    "severity" : "normal",
+    "retries" : [ ],
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "7af172a2303b627d.json",
+  "parameterValues" : [ "'添加维度'", "{'code': 'api_auto_test_add_dem', 'description': 'api_auto_test_add_dem', 'isDefault': 0, 'name': 'api_auto_test_add_dem'}", "'高'", "'正向用例'", "{'message': '添加维度成功！'}", "'pOst'", "'json'", "'维度管理'", "'delete FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'delete'", "None", "'http://120.46.172.186:8080/api/demension/v1/dem/addDem'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/7efd9dd32f98b518.json

+{
+  "uid" : "7efd9dd32f98b518",
+  "name" : "test用例函数-依赖登录成功和添加维度成功",
+  "fullName" : "test_case.test_dependency.test_dependency#test1",
+  "historyId" : "112831bd8b103ba5270ea46bde2822af",
+  "time" : {
+    "start" : 1716272633097,
+    "stop" : 1716272633098,
+    "duration" : 1
+  },
+  "status" : "passed",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "passed",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "7ca9dc953c624cc6",
+      "name" : "stdout",
+      "source" : "7ca9dc953c624cc6.txt",
+      "type" : "text/plain",
+      "size" : 14
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : false
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "story",
+    "value" : "test"
+  }, {
+    "name" : "feature",
+    "value" : "test"
+  }, {
+    "name" : "epic",
+    "value" : "BPM-场景测试"
+  }, {
+    "name" : "tag",
+    "value" : "dependency(depends=['test_add_dem', 'test_login'])"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_dependency"
+  }, {
+    "name" : "suite",
+    "value" : "test_dependency"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_dependency.test_dependency"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ ],
+  "links" : [ ],
+  "hidden" : false,
+  "retry" : false,
+  "extra" : {
+    "severity" : "normal",
+    "retries" : [ ],
+    "categories" : [ ],
+    "tags" : [ "dependency(depends=['test_add_dem', 'test_login'])" ]
+  },
+  "source" : "7efd9dd32f98b518.json",
+  "parameterValues" : [ ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/80142e22de024a60.json

+{
+  "uid" : "80142e22de024a60",
+  "name" : "正向用例-正确输入用户名和密码",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "f7417fae3641334c555177156c21126d",
+  "time" : {
+    "start" : 1716272598748,
+    "stop" : 1716272598811,
+    "duration" : 63
+  },
+  "status" : "passed",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "passed",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "5a84d42ab44260be",
+      "name" : "log",
+      "source" : "5a84d42ab44260be.txt",
+      "type" : "text/plain",
+      "size" : 575
+    }, {
+      "uid" : "4b82c6a38a94e361",
+      "name" : "stdout",
+      "source" : "4b82c6a38a94e361.txt",
+      "type" : "text/plain",
+      "size" : 7
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 2,
+    "shouldDisplayMessage" : false
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "认证接口"
+  }, {
+    "name" : "story",
+    "value" : "登录系统"
+  }, {
+    "name" : "severity",
+    "value" : "高"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'登录系统'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'username': 'admin', 'password': 'MTIzNDU2'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'高'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例-正确输入用户名和密码'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'username': '超级管理员', 'loginStatus': True, 'account': 'admin'}"
+  }, {
+    "name" : "method",
+    "value" : "'POST'"
+  }, {
+    "name" : "mime",
+    "value" : "'application/json'"
+  }, {
+    "name" : "module_name",
+    "value" : "'认证接口'"
+  }, {
+    "name" : "sql_data",
+    "value" : "None"
+  }, {
+    "name" : "sql_type",
+    "value" : "None"
+  }, {
+    "name" : "update_key",
+    "value" : "None"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/auth'"
+  } ],
+  "links" : [ ],
+  "hidden" : false,
+  "retry" : false,
+  "extra" : {
+    "severity" : "normal",
+    "retries" : [ ],
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "80142e22de024a60.json",
+  "parameterValues" : [ "'登录系统'", "{'username': 'admin', 'password': 'MTIzNDU2'}", "'高'", "'正向用例-正确输入用户名和密码'", "{'username': '超级管理员', 'loginStatus': True, 'account': 'admin'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/8142d41860b04b15.json

+{
+  "uid" : "8142d41860b04b15",
+  "name" : "反向用例-密码正确,用户名过长",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "968bf5f1bc5266807075e84dfd49d322",
+  "time" : {
+    "start" : 1716272599315,
+    "stop" : 1716272599407,
+    "duration" : 92
+  },
+  "status" : "passed",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "passed",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "195d3c3ed8fa0070",
+      "name" : "log",
+      "source" : "195d3c3ed8fa0070.txt",
+      "type" : "text/plain",
+      "size" : 298
+    }, {
+      "uid" : "e225611ab025f71d",
+      "name" : "stdout",
+      "source" : "e225611ab025f71d.txt",
+      "type" : "text/plain",
+      "size" : 7
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 2,
+    "shouldDisplayMessage" : false
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "认证接口"
+  }, {
+    "name" : "story",
+    "value" : "登录系统"
+  }, {
+    "name" : "severity",
+    "value" : "中"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'登录系统'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'username': 'adminadminadminadmin', 'password': 'MTIzNDU2'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'中'"
+  }, {
+    "name" : "case_title",
+    "value" : "'反向用例-密码正确,用户名过长'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '账号或密码错误'}"
+  }, {
+    "name" : "method",
+    "value" : "'POST'"
+  }, {
+    "name" : "mime",
+    "value" : "'json'"
+  }, {
+    "name" : "module_name",
+    "value" : "'认证接口'"
+  }, {
+    "name" : "sql_data",
+    "value" : "None"
+  }, {
+    "name" : "sql_type",
+    "value" : "None"
+  }, {
+    "name" : "update_key",
+    "value" : "None"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/auth'"
+  } ],
+  "links" : [ ],
+  "hidden" : false,
+  "retry" : false,
+  "extra" : {
+    "severity" : "normal",
+    "retries" : [ ],
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "8142d41860b04b15.json",
+  "parameterValues" : [ "'登录系统'", "{'username': 'adminadminadminadmin', 'password': 'MTIzNDU2'}", "'中'", "'反向用例-密码正确,用户名过长'", "{'message': '账号或密码错误'}", "'POST'", "'json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/88e60d865858edc2.json

+{
+  "uid" : "88e60d865858edc2",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "347d2f73ed73495ba7ba72dbf723f253",
+  "time" : {
+    "start" : 1716272624099,
+    "stop" : 1716272624187,
+    "duration" : 88
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "6ea91b34562fdff6",
+      "name" : "log",
+      "source" : "6ea91b34562fdff6.txt",
+      "type" : "text/plain",
+      "size" : 490
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "维度管理"
+  }, {
+    "name" : "story",
+    "value" : "根据维度编码删除维度"
+  }, {
+    "name" : "severity",
+    "value" : "中"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'根据维度编码删除维度'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'ids': '1792803379156631552'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'中'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '删除维度成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'DELETE'"
+  }, {
+    "name" : "mime",
+    "value" : "'query'"
+  }, {
+    "name" : "module_name",
+    "value" : "'维度管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"
+  }, {
+    "name" : "sql_type",
+    "value" : "'select'"
+  }, {
+    "name" : "update_key",
+    "value" : "'ids'"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'"
+  } ],
+  "links" : [ ],
+  "hidden" : true,
+  "retry" : true,
+  "extra" : {
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "88e60d865858edc2.json",
+  "parameterValues" : [ "'根据维度编码删除维度'", "{'ids': '1792803379156631552'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/96596e0fab9d3415.json

+{
+  "uid" : "96596e0fab9d3415",
+  "name" : "反向用例-密码正确,用户名过短",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "1a3971dd942170d7f7bcf2c1f2eecd8f",
+  "time" : {
+    "start" : 1716272599418,
+    "stop" : 1716272599517,
+    "duration" : 99
+  },
+  "status" : "passed",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "passed",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "a66f6f015a0908d7",
+      "name" : "log",
+      "source" : "a66f6f015a0908d7.txt",
+      "type" : "text/plain",
+      "size" : 279
+    }, {
+      "uid" : "c3a3b7a3c91bcff7",
+      "name" : "stdout",
+      "source" : "c3a3b7a3c91bcff7.txt",
+      "type" : "text/plain",
+      "size" : 7
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 2,
+    "shouldDisplayMessage" : false
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "认证接口"
+  }, {
+    "name" : "story",
+    "value" : "登录系统"
+  }, {
+    "name" : "severity",
+    "value" : "中"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'登录系统'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'username': 'a', 'password': 'MTIzNDU2'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'中'"
+  }, {
+    "name" : "case_title",
+    "value" : "'反向用例-密码正确,用户名过短'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '账号或密码错误'}"
+  }, {
+    "name" : "method",
+    "value" : "'POST'"
+  }, {
+    "name" : "mime",
+    "value" : "'application/json'"
+  }, {
+    "name" : "module_name",
+    "value" : "'认证接口'"
+  }, {
+    "name" : "sql_data",
+    "value" : "None"
+  }, {
+    "name" : "sql_type",
+    "value" : "None"
+  }, {
+    "name" : "update_key",
+    "value" : "None"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/auth'"
+  } ],
+  "links" : [ ],
+  "hidden" : false,
+  "retry" : false,
+  "extra" : {
+    "severity" : "normal",
+    "retries" : [ ],
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "96596e0fab9d3415.json",
+  "parameterValues" : [ "'登录系统'", "{'username': 'a', 'password': 'MTIzNDU2'}", "'中'", "'反向用例-密码正确,用户名过短'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/9a2316575f97b91e.json

+{
+  "uid" : "9a2316575f97b91e",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "db26a6f22fbc123482ea90d3e77fa9fd",
+  "time" : {
+    "start" : 1716272621920,
+    "stop" : 1716272621978,
+    "duration" : 58
+  },
+  "status" : "passed",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "passed",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "8f0dd4d860439e9d",
+      "name" : "log",
+      "source" : "8f0dd4d860439e9d.txt",
+      "type" : "text/plain",
+      "size" : 258
+    }, {
+      "uid" : "d58b94aaa68aa2dd",
+      "name" : "stdout",
+      "source" : "d58b94aaa68aa2dd.txt",
+      "type" : "text/plain",
+      "size" : 7
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 2,
+    "shouldDisplayMessage" : false
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "组织管理"
+  }, {
+    "name" : "story",
+    "value" : "删除组织"
+  }, {
+    "name" : "severity",
+    "value" : "高"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'删除组织'"
+  }, {
+    "name" : "case_data",
+    "value" : "'test_add_org'"
+  }, {
+    "name" : "case_level",
+    "value" : "'高'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'state': True, 'message': '删除组织成功！', 'value': ''}"
+  }, {
+    "name" : "method",
+    "value" : "'POST'"
+  }, {
+    "name" : "mime",
+    "value" : "'text/plain'"
+  }, {
+    "name" : "module_name",
+    "value" : "'组织管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "None"
+  }, {
+    "name" : "sql_type",
+    "value" : "None"
+  }, {
+    "name" : "update_key",
+    "value" : "None"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/org/v1/org/deleteOrg'"
+  } ],
+  "links" : [ ],
+  "hidden" : false,
+  "retry" : false,
+  "extra" : {
+    "severity" : "normal",
+    "retries" : [ ],
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "9a2316575f97b91e.json",
+  "parameterValues" : [ "'删除组织'", "'test_add_org'", "'高'", "'正向用例'", "{'state': True, 'message': '删除组织成功！', 'value': ''}", "'POST'", "'text/plain'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/org/deleteOrg'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/9d2f1604d71ec7a6.json

+{
+  "uid" : "9d2f1604d71ec7a6",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "487ae598a2b30a5ea2489bb3e5fa08a4",
+  "time" : {
+    "start" : 1716272619383,
+    "stop" : 1716272619564,
+    "duration" : 181
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "6e082c14d64f516c",
+      "name" : "log",
+      "source" : "6e082c14d64f516c.txt",
+      "type" : "text/plain",
+      "size" : 1989
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "组织管理"
+  }, {
+    "name" : "story",
+    "value" : "添加组织"
+  }, {
+    "name" : "severity",
+    "value" : "高"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'添加组织'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'高'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '添加组织成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'POST'"
+  }, {
+    "name" : "mime",
+    "value" : "'json'"
+  }, {
+    "name" : "module_name",
+    "value" : "'组织管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}"
+  }, {
+    "name" : "sql_type",
+    "value" : "'select|delete'"
+  }, {
+    "name" : "update_key",
+    "value" : "'demId'"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/org/v1/org/addOrg'"
+  } ],
+  "links" : [ ],
+  "hidden" : true,
+  "retry" : true,
+  "extra" : {
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "9d2f1604d71ec7a6.json",
+  "parameterValues" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/a011264732c293ec.json

+{
+  "uid" : "a011264732c293ec",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "347d2f73ed73495ba7ba72dbf723f253",
+  "time" : {
+    "start" : 1716272626207,
+    "stop" : 1716272626341,
+    "duration" : 134
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "436d5cd427874b03",
+      "name" : "log",
+      "source" : "436d5cd427874b03.txt",
+      "type" : "text/plain",
+      "size" : 735
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "维度管理"
+  }, {
+    "name" : "story",
+    "value" : "根据维度编码删除维度"
+  }, {
+    "name" : "severity",
+    "value" : "中"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'根据维度编码删除维度'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'ids': '1792803379156631552'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'中'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '删除维度成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'DELETE'"
+  }, {
+    "name" : "mime",
+    "value" : "'query'"
+  }, {
+    "name" : "module_name",
+    "value" : "'维度管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"
+  }, {
+    "name" : "sql_type",
+    "value" : "'select'"
+  }, {
+    "name" : "update_key",
+    "value" : "'ids'"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'"
+  } ],
+  "links" : [ ],
+  "hidden" : true,
+  "retry" : true,
+  "extra" : {
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "a011264732c293ec.json",
+  "parameterValues" : [ "'根据维度编码删除维度'", "{'ids': '1792803379156631552'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/a0b87df8f50dc316.json

+{
+  "uid" : "a0b87df8f50dc316",
+  "name" : "反向用例-密码正确,用户名错误",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "83d67cdc5550a580709b5379b214757d",
+  "time" : {
+    "start" : 1716272599640,
+    "stop" : 1716272599737,
+    "duration" : 97
+  },
+  "status" : "passed",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "passed",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "ba6929d93441163b",
+      "name" : "log",
+      "source" : "ba6929d93441163b.txt",
+      "type" : "text/plain",
+      "size" : 286
+    }, {
+      "uid" : "8a43ab00612fb800",
+      "name" : "stdout",
+      "source" : "8a43ab00612fb800.txt",
+      "type" : "text/plain",
+      "size" : 7
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 2,
+    "shouldDisplayMessage" : false
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "认证接口"
+  }, {
+    "name" : "story",
+    "value" : "登录系统"
+  }, {
+    "name" : "severity",
+    "value" : "中"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'登录系统'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'username': 'admin123', 'password': 'MTIzNDU2'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'中'"
+  }, {
+    "name" : "case_title",
+    "value" : "'反向用例-密码正确,用户名错误'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '账号或密码错误'}"
+  }, {
+    "name" : "method",
+    "value" : "'POST'"
+  }, {
+    "name" : "mime",
+    "value" : "'application/json'"
+  }, {
+    "name" : "module_name",
+    "value" : "'认证接口'"
+  }, {
+    "name" : "sql_data",
+    "value" : "None"
+  }, {
+    "name" : "sql_type",
+    "value" : "None"
+  }, {
+    "name" : "update_key",
+    "value" : "None"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/auth'"
+  } ],
+  "links" : [ ],
+  "hidden" : false,
+  "retry" : false,
+  "extra" : {
+    "severity" : "normal",
+    "retries" : [ ],
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "a0b87df8f50dc316.json",
+  "parameterValues" : [ "'登录系统'", "{'username': 'admin123', 'password': 'MTIzNDU2'}", "'中'", "'反向用例-密码正确,用户名错误'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/adb4666aed6ea6fd.json

+{
+  "uid" : "adb4666aed6ea6fd",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm",
+  "historyId" : "2d767e403ea75ccb1f14fcd976c25353",
+  "time" : {
+    "start" : 1716272644756,
+    "stop" : 1716272644809,
+    "duration" : 53
+  },
+  "status" : "passed",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "passed",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "26ab91eb58d5437f",
+      "name" : "log",
+      "source" : "26ab91eb58d5437f.txt",
+      "type" : "text/plain",
+      "size" : 276
+    }, {
+      "uid" : "6413450afbe297d",
+      "name" : "stdout",
+      "source" : "6413450afbe297d.txt",
+      "type" : "text/plain",
+      "size" : 7
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 2,
+    "shouldDisplayMessage" : false
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "组织管理"
+  }, {
+    "name" : "story",
+    "value" : "组织加入用户"
+  }, {
+    "name" : "severity",
+    "value" : "高"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-老张"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_mirZhang"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_mirZhang.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'组织加入用户'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'orgCode': 'test_add_org', 'accounts': 'admin'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'高'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'state': True, 'message': '加入成功', 'value': ''}"
+  }, {
+    "name" : "method",
+    "value" : "'POST'"
+  }, {
+    "name" : "mime",
+    "value" : "'query'"
+  }, {
+    "name" : "module_name",
+    "value" : "'组织管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "None"
+  }, {
+    "name" : "sql_type",
+    "value" : "None"
+  }, {
+    "name" : "update_key",
+    "value" : "None"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/org/v1/orgUsers/addUsersForOrg'"
+  } ],
+  "links" : [ ],
+  "hidden" : false,
+  "retry" : false,
+  "extra" : {
+    "severity" : "normal",
+    "retries" : [ ],
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "adb4666aed6ea6fd.json",
+  "parameterValues" : [ "'组织加入用户'", "{'orgCode': 'test_add_org', 'accounts': 'admin'}", "'高'", "'正向用例'", "{'state': True, 'message': '加入成功', 'value': ''}", "'POST'", "'query'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/orgUsers/addUsersForOrg'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/b477169fbff4410e.json

+{
+  "uid" : "b477169fbff4410e",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "347d2f73ed73495ba7ba72dbf723f253",
+  "time" : {
+    "start" : 1716272621987,
+    "stop" : 1716272622080,
+    "duration" : 93
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '删除维度成功' == '删除维度成功！'\n  \n  - 删除维度成功！\n  ?       -\n  + 删除维度成功",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == '删除维度成功！'\nE                 \nE                 - 删除维度成功！\nE                 ?       -\nE                 + 删除维度成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '删除维度成功' == '删除维度成功！'\n  \n  - 删除维度成功！\n  ?       -\n  + 删除维度成功",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == '删除维度成功！'\nE                 \nE                 - 删除维度成功！\nE                 ?       -\nE                 + 删除维度成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "bbd501f9dbcd3dda",
+      "name" : "log",
+      "source" : "bbd501f9dbcd3dda.txt",
+      "type" : "text/plain",
+      "size" : 245
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "维度管理"
+  }, {
+    "name" : "story",
+    "value" : "根据维度编码删除维度"
+  }, {
+    "name" : "severity",
+    "value" : "中"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'根据维度编码删除维度'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'ids': '需要更新'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'中'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '删除维度成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'DELETE'"
+  }, {
+    "name" : "mime",
+    "value" : "'query'"
+  }, {
+    "name" : "module_name",
+    "value" : "'维度管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"
+  }, {
+    "name" : "sql_type",
+    "value" : "'select'"
+  }, {
+    "name" : "update_key",
+    "value" : "'ids'"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'"
+  } ],
+  "links" : [ ],
+  "hidden" : true,
+  "retry" : true,
+  "extra" : {
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "b477169fbff4410e.json",
+  "parameterValues" : [ "'根据维度编码删除维度'", "{'ids': '需要更新'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/b6d10bbf3ce5a604.json

+{
+  "uid" : "b6d10bbf3ce5a604",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm",
+  "historyId" : "5ee7a985530eff8db65cbc3fbd8fd151",
+  "time" : {
+    "start" : 1716272644883,
+    "stop" : 1716272644938,
+    "duration" : 55
+  },
+  "status" : "passed",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "passed",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "daf1a95306848a3",
+      "name" : "log",
+      "source" : "daf1a95306848a3.txt",
+      "type" : "text/plain",
+      "size" : 258
+    }, {
+      "uid" : "987782255dd3f0f5",
+      "name" : "stdout",
+      "source" : "987782255dd3f0f5.txt",
+      "type" : "text/plain",
+      "size" : 7
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 2,
+    "shouldDisplayMessage" : false
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "组织管理"
+  }, {
+    "name" : "story",
+    "value" : "删除组织"
+  }, {
+    "name" : "severity",
+    "value" : "高"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-老张"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_mirZhang"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_mirZhang.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'删除组织'"
+  }, {
+    "name" : "case_data",
+    "value" : "'test_add_org'"
+  }, {
+    "name" : "case_level",
+    "value" : "'高'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'state': True, 'message': '删除组织成功！', 'value': ''}"
+  }, {
+    "name" : "method",
+    "value" : "'POST'"
+  }, {
+    "name" : "mime",
+    "value" : "'text/plain'"
+  }, {
+    "name" : "module_name",
+    "value" : "'组织管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "None"
+  }, {
+    "name" : "sql_type",
+    "value" : "None"
+  }, {
+    "name" : "update_key",
+    "value" : "None"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/org/v1/org/deleteOrg'"
+  } ],
+  "links" : [ ],
+  "hidden" : false,
+  "retry" : false,
+  "extra" : {
+    "severity" : "normal",
+    "retries" : [ ],
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "b6d10bbf3ce5a604.json",
+  "parameterValues" : [ "'删除组织'", "'test_add_org'", "'高'", "'正向用例'", "{'state': True, 'message': '删除组织成功！', 'value': ''}", "'POST'", "'text/plain'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/org/deleteOrg'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/bab371eff6794f2b.json

+{
+  "uid" : "bab371eff6794f2b",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm",
+  "historyId" : "526f1fd519b78b4955668d6cfd277048",
+  "time" : {
+    "start" : 1716272637956,
+    "stop" : 1716272638139,
+    "duration" : 183
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "cf084e108e2df99e",
+      "name" : "log",
+      "source" : "cf084e108e2df99e.txt",
+      "type" : "text/plain",
+      "size" : 1193
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "组织管理"
+  }, {
+    "name" : "story",
+    "value" : "添加组织"
+  }, {
+    "name" : "severity",
+    "value" : "高"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-老张"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_mirZhang"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_mirZhang.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'添加组织'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'高'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '添加组织成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'POST'"
+  }, {
+    "name" : "mime",
+    "value" : "'json'"
+  }, {
+    "name" : "module_name",
+    "value" : "'组织管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}"
+  }, {
+    "name" : "sql_type",
+    "value" : "'select|delete'"
+  }, {
+    "name" : "update_key",
+    "value" : "'demId'"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/org/v1/org/addOrg'"
+  } ],
+  "links" : [ ],
+  "hidden" : true,
+  "retry" : true,
+  "extra" : {
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "bab371eff6794f2b.json",
+  "parameterValues" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/c26c17d72f28aa7f.json

+{
+  "uid" : "c26c17d72f28aa7f",
+  "name" : "反向用例-用户名正确,密码过长",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "37bde76add67e3f73e804e1ff293bbd9",
+  "time" : {
+    "start" : 1716272598895,
+    "stop" : 1716272598989,
+    "duration" : 94
+  },
+  "status" : "passed",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "passed",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "a9bcf4a95c5389c9",
+      "name" : "log",
+      "source" : "a9bcf4a95c5389c9.txt",
+      "type" : "text/plain",
+      "size" : 355
+    }, {
+      "uid" : "bd632cb85700b6eb",
+      "name" : "stdout",
+      "source" : "bd632cb85700b6eb.txt",
+      "type" : "text/plain",
+      "size" : 7
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 2,
+    "shouldDisplayMessage" : false
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "认证接口"
+  }, {
+    "name" : "story",
+    "value" : "登录系统"
+  }, {
+    "name" : "severity",
+    "value" : "中"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'登录系统'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'username': 'admin', 'password': 'MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'中'"
+  }, {
+    "name" : "case_title",
+    "value" : "'反向用例-用户名正确,密码过长'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '账号或密码错误'}"
+  }, {
+    "name" : "method",
+    "value" : "'POST'"
+  }, {
+    "name" : "mime",
+    "value" : "'application/json'"
+  }, {
+    "name" : "module_name",
+    "value" : "'认证接口'"
+  }, {
+    "name" : "sql_data",
+    "value" : "None"
+  }, {
+    "name" : "sql_type",
+    "value" : "None"
+  }, {
+    "name" : "update_key",
+    "value" : "None"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/auth'"
+  } ],
+  "links" : [ ],
+  "hidden" : false,
+  "retry" : false,
+  "extra" : {
+    "severity" : "normal",
+    "retries" : [ ],
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "c26c17d72f28aa7f.json",
+  "parameterValues" : [ "'登录系统'", "{'username': 'admin', 'password': 'MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2'}", "'中'", "'反向用例-用户名正确,密码过长'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/c2d850dec3954142.json

+{
+  "uid" : "c2d850dec3954142",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "1dcae5f805bddffd6ce19e14c8b3458b",
+  "time" : {
+    "start" : 1716272604095,
+    "stop" : 1716272604145,
+    "duration" : 50
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '刷新token成功' == None\n +  where None = <built-in method get of dict object at 0x0000014F19157400>('message')\n +    where <built-in method get of dict object at 0x0000014F19157400> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwMn0.2ULfoTRcxys6pnuEKjHxZH4GI20D2qBisJFYoBn2GdZLw23Xapl1u2ATzI1w5cFlBcJf3_bFyVN7eo7OfOOMUg', 'userAttrs': {}, ...}.get\n +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwMn0.2ULfoTRcxys6pnuEKjHxZH4GI20D2qBisJFYoBn2GdZLw23Xapl1u2ATzI1w5cFlBcJf3_bFyVN7eo7OfOOMUg', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\n +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '刷新token成功' == None\nE                +  where None = <built-in method get of dict object at 0x0000014F19157400>('message')\nE                +    where <built-in method get of dict object at 0x0000014F19157400> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwMn0.2ULfoTRcxys6pnuEKjHxZH4GI20D2qBisJFYoBn2GdZLw23Xapl1u2ATzI1w5cFlBcJf3_bFyVN7eo7OfOOMUg', 'userAttrs': {}, ...}.get\nE                +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwMn0.2ULfoTRcxys6pnuEKjHxZH4GI20D2qBisJFYoBn2GdZLw23Xapl1u2ATzI1w5cFlBcJf3_bFyVN7eo7OfOOMUg', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\nE                +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '刷新token成功' == None\n +  where None = <built-in method get of dict object at 0x0000014F19157400>('message')\n +    where <built-in method get of dict object at 0x0000014F19157400> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwMn0.2ULfoTRcxys6pnuEKjHxZH4GI20D2qBisJFYoBn2GdZLw23Xapl1u2ATzI1w5cFlBcJf3_bFyVN7eo7OfOOMUg', 'userAttrs': {}, ...}.get\n +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwMn0.2ULfoTRcxys6pnuEKjHxZH4GI20D2qBisJFYoBn2GdZLw23Xapl1u2ATzI1w5cFlBcJf3_bFyVN7eo7OfOOMUg', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\n +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '刷新token成功' == None\nE                +  where None = <built-in method get of dict object at 0x0000014F19157400>('message')\nE                +    where <built-in method get of dict object at 0x0000014F19157400> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwMn0.2ULfoTRcxys6pnuEKjHxZH4GI20D2qBisJFYoBn2GdZLw23Xapl1u2ATzI1w5cFlBcJf3_bFyVN7eo7OfOOMUg', 'userAttrs': {}, ...}.get\nE                +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwMn0.2ULfoTRcxys6pnuEKjHxZH4GI20D2qBisJFYoBn2GdZLw23Xapl1u2ATzI1w5cFlBcJf3_bFyVN7eo7OfOOMUg', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\nE                +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "dde9a1e6e87f25aa",
+      "name" : "log",
+      "source" : "dde9a1e6e87f25aa.txt",
+      "type" : "text/plain",
+      "size" : 1319
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "认证接口"
+  }, {
+    "name" : "story",
+    "value" : "刷新token"
+  }, {
+    "name" : "severity",
+    "value" : "中"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'刷新token'"
+  }, {
+    "name" : "case_data",
+    "value" : "None"
+  }, {
+    "name" : "case_level",
+    "value" : "'中'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '刷新token成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'GET'"
+  }, {
+    "name" : "mime",
+    "value" : "None"
+  }, {
+    "name" : "module_name",
+    "value" : "'认证接口'"
+  }, {
+    "name" : "sql_data",
+    "value" : "None"
+  }, {
+    "name" : "sql_type",
+    "value" : "None"
+  }, {
+    "name" : "update_key",
+    "value" : "None"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/refresh'"
+  } ],
+  "links" : [ ],
+  "hidden" : true,
+  "retry" : true,
+  "extra" : {
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "c2d850dec3954142.json",
+  "parameterValues" : [ "'刷新token'", "None", "'中'", "'正向用例'", "{'message': '刷新token成功'}", "'GET'", "None", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/refresh'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/cc6c15cf3215c8cc.json

+{
+  "uid" : "cc6c15cf3215c8cc",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "347d2f73ed73495ba7ba72dbf723f253",
+  "time" : {
+    "start" : 1716272632686,
+    "stop" : 1716272632817,
+    "duration" : 131
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "879a46074811af0",
+      "name" : "log",
+      "source" : "879a46074811af0.txt",
+      "type" : "text/plain",
+      "size" : 1470
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "维度管理"
+  }, {
+    "name" : "story",
+    "value" : "根据维度编码删除维度"
+  }, {
+    "name" : "severity",
+    "value" : "中"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'根据维度编码删除维度'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'ids': '1792803379156631552'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'中'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '删除维度成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'DELETE'"
+  }, {
+    "name" : "mime",
+    "value" : "'query'"
+  }, {
+    "name" : "module_name",
+    "value" : "'维度管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"
+  }, {
+    "name" : "sql_type",
+    "value" : "'select'"
+  }, {
+    "name" : "update_key",
+    "value" : "'ids'"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'"
+  } ],
+  "links" : [ ],
+  "hidden" : false,
+  "retry" : false,
+  "extra" : {
+    "severity" : "normal",
+    "retries" : [ {
+      "uid" : "64c7a0a97adde6d1",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+      "time" : {
+        "start" : 1716272630526,
+        "stop" : 1716272630660,
+        "duration" : 134
+      }
+    }, {
+      "uid" : "d1e0d7501f9ea60",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+      "time" : {
+        "start" : 1716272628366,
+        "stop" : 1716272628501,
+        "duration" : 135
+      }
+    }, {
+      "uid" : "a011264732c293ec",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+      "time" : {
+        "start" : 1716272626207,
+        "stop" : 1716272626341,
+        "duration" : 134
+      }
+    }, {
+      "uid" : "88e60d865858edc2",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+      "time" : {
+        "start" : 1716272624099,
+        "stop" : 1716272624187,
+        "duration" : 88
+      }
+    }, {
+      "uid" : "b477169fbff4410e",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '删除维度成功' == '删除维度成功！'\n  \n  - 删除维度成功！\n  ?       -\n  + 删除维度成功",
+      "time" : {
+        "start" : 1716272621987,
+        "stop" : 1716272622080,
+        "duration" : 93
+      }
+    } ],
+    "categories" : [ {
+      "name" : "Product defects",
+      "matchedStatuses" : [ ],
+      "flaky" : false
+    } ],
+    "tags" : [ ]
+  },
+  "source" : "cc6c15cf3215c8cc.json",
+  "parameterValues" : [ "'根据维度编码删除维度'", "{'ids': '1792803379156631552'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/ce412b2b5e44b608.json

+{
+  "uid" : "ce412b2b5e44b608",
+  "name" : "登录--前置",
+  "fullName" : "test_case.test_dependency.test_dependency#test_login",
+  "historyId" : "b3ea99bce5fbf89dc61e67ffc74d2796",
+  "time" : {
+    "start" : 1716272632845,
+    "stop" : 1716272632940,
+    "duration" : 95
+  },
+  "status" : "passed",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "passed",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "93c840dec4b9b526",
+      "name" : "stdout",
+      "source" : "93c840dec4b9b526.txt",
+      "type" : "text/plain",
+      "size" : 13
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : false
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "认证接口"
+  }, {
+    "name" : "story",
+    "value" : "登录系统"
+  }, {
+    "name" : "epic",
+    "value" : "BPM-场景测试"
+  }, {
+    "name" : "tag",
+    "value" : "dependency"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_dependency"
+  }, {
+    "name" : "suite",
+    "value" : "test_dependency"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_dependency.test_dependency"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ ],
+  "links" : [ ],
+  "hidden" : false,
+  "retry" : false,
+  "extra" : {
+    "severity" : "normal",
+    "retries" : [ ],
+    "categories" : [ ],
+    "tags" : [ "dependency" ]
+  },
+  "source" : "ce412b2b5e44b608.json",
+  "parameterValues" : [ ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/d093b8587a3ab4f3.json

+{
+  "uid" : "d093b8587a3ab4f3",
+  "name" : "反向用例-用户名正确,密码为特殊字符",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "45fbe766301d5f34f2314154dd48ad7c",
+  "time" : {
+    "start" : 1716272599103,
+    "stop" : 1716272599203,
+    "duration" : 100
+  },
+  "status" : "passed",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "passed",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "4c9392d6daa2384",
+      "name" : "log",
+      "source" : "4c9392d6daa2384.txt",
+      "type" : "text/plain",
+      "size" : 287
+    }, {
+      "uid" : "ac741aa1898e1262",
+      "name" : "stdout",
+      "source" : "ac741aa1898e1262.txt",
+      "type" : "text/plain",
+      "size" : 7
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 2,
+    "shouldDisplayMessage" : false
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "认证接口"
+  }, {
+    "name" : "story",
+    "value" : "登录系统"
+  }, {
+    "name" : "severity",
+    "value" : "中"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'登录系统'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'username': 'admin', 'password': '☯㍿卍卐'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'中'"
+  }, {
+    "name" : "case_title",
+    "value" : "'反向用例-用户名正确,密码为特殊字符'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '账号或密码错误'}"
+  }, {
+    "name" : "method",
+    "value" : "'POST'"
+  }, {
+    "name" : "mime",
+    "value" : "'application/json'"
+  }, {
+    "name" : "module_name",
+    "value" : "'认证接口'"
+  }, {
+    "name" : "sql_data",
+    "value" : "None"
+  }, {
+    "name" : "sql_type",
+    "value" : "None"
+  }, {
+    "name" : "update_key",
+    "value" : "None"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/auth'"
+  } ],
+  "links" : [ ],
+  "hidden" : false,
+  "retry" : false,
+  "extra" : {
+    "severity" : "normal",
+    "retries" : [ ],
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "d093b8587a3ab4f3.json",
+  "parameterValues" : [ "'登录系统'", "{'username': 'admin', 'password': '☯㍿卍卐'}", "'中'", "'反向用例-用户名正确,密码为特殊字符'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/d1e0d7501f9ea60.json

+{
+  "uid" : "d1e0d7501f9ea60",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "347d2f73ed73495ba7ba72dbf723f253",
+  "time" : {
+    "start" : 1716272628366,
+    "stop" : 1716272628501,
+    "duration" : 135
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "68079d64d13b4b9b",
+      "name" : "log",
+      "source" : "68079d64d13b4b9b.txt",
+      "type" : "text/plain",
+      "size" : 980
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "维度管理"
+  }, {
+    "name" : "story",
+    "value" : "根据维度编码删除维度"
+  }, {
+    "name" : "severity",
+    "value" : "中"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'根据维度编码删除维度'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'ids': '1792803379156631552'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'中'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '删除维度成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'DELETE'"
+  }, {
+    "name" : "mime",
+    "value" : "'query'"
+  }, {
+    "name" : "module_name",
+    "value" : "'维度管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"
+  }, {
+    "name" : "sql_type",
+    "value" : "'select'"
+  }, {
+    "name" : "update_key",
+    "value" : "'ids'"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'"
+  } ],
+  "links" : [ ],
+  "hidden" : true,
+  "retry" : true,
+  "extra" : {
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "d1e0d7501f9ea60.json",
+  "parameterValues" : [ "'根据维度编码删除维度'", "{'ids': '1792803379156631552'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/d386a81c173e63a4.json

+{
+  "uid" : "d386a81c173e63a4",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm",
+  "historyId" : "526f1fd519b78b4955668d6cfd277048",
+  "time" : {
+    "start" : 1716272633544,
+    "stop" : 1716272633720,
+    "duration" : 176
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "e05bc2e897e525cd",
+      "name" : "log",
+      "source" : "e05bc2e897e525cd.txt",
+      "type" : "text/plain",
+      "size" : 397
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "组织管理"
+  }, {
+    "name" : "story",
+    "value" : "添加组织"
+  }, {
+    "name" : "severity",
+    "value" : "高"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-老张"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_mirZhang"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_mirZhang.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'添加组织'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'code': 'test_add_org', 'demId': '需要更新', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'高'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '添加组织成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'POST'"
+  }, {
+    "name" : "mime",
+    "value" : "'json'"
+  }, {
+    "name" : "module_name",
+    "value" : "'组织管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}"
+  }, {
+    "name" : "sql_type",
+    "value" : "'select|delete'"
+  }, {
+    "name" : "update_key",
+    "value" : "'demId'"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/org/v1/org/addOrg'"
+  } ],
+  "links" : [ ],
+  "hidden" : true,
+  "retry" : true,
+  "extra" : {
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "d386a81c173e63a4.json",
+  "parameterValues" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '需要更新', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/d86d7ab21b67c470.json

+{
+  "uid" : "d86d7ab21b67c470",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm",
+  "historyId" : "526f1fd519b78b4955668d6cfd277048",
+  "time" : {
+    "start" : 1716272635752,
+    "stop" : 1716272635930,
+    "duration" : 178
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "b398dd14596ef633",
+      "name" : "log",
+      "source" : "b398dd14596ef633.txt",
+      "type" : "text/plain",
+      "size" : 795
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "组织管理"
+  }, {
+    "name" : "story",
+    "value" : "添加组织"
+  }, {
+    "name" : "severity",
+    "value" : "高"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-老张"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_mirZhang"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_mirZhang.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'添加组织'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'高'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '添加组织成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'POST'"
+  }, {
+    "name" : "mime",
+    "value" : "'json'"
+  }, {
+    "name" : "module_name",
+    "value" : "'组织管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}"
+  }, {
+    "name" : "sql_type",
+    "value" : "'select|delete'"
+  }, {
+    "name" : "update_key",
+    "value" : "'demId'"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/org/v1/org/addOrg'"
+  } ],
+  "links" : [ ],
+  "hidden" : true,
+  "retry" : true,
+  "extra" : {
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "d86d7ab21b67c470.json",
+  "parameterValues" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/dd7fa74e2935b20a.json

+{
+  "uid" : "dd7fa74e2935b20a",
+  "name" : "添加维度-依赖登录",
+  "fullName" : "test_case.test_dependency.test_dependency#test_add_dem",
+  "historyId" : "2c19ea97cbbe4cb31079c2ee05828120",
+  "time" : {
+    "start" : 1716272632942,
+    "stop" : 1716272633094,
+    "duration" : 152
+  },
+  "status" : "passed",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "passed",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "c8901e6970c427be",
+      "name" : "stdout",
+      "source" : "c8901e6970c427be.txt",
+      "type" : "text/plain",
+      "size" : 13
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : false
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "维度管理"
+  }, {
+    "name" : "story",
+    "value" : "添加维度"
+  }, {
+    "name" : "epic",
+    "value" : "BPM-场景测试"
+  }, {
+    "name" : "tag",
+    "value" : "dependency(depends=['test_login'])"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_dependency"
+  }, {
+    "name" : "suite",
+    "value" : "test_dependency"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_dependency.test_dependency"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ ],
+  "links" : [ ],
+  "hidden" : false,
+  "retry" : false,
+  "extra" : {
+    "severity" : "normal",
+    "retries" : [ ],
+    "categories" : [ ],
+    "tags" : [ "dependency(depends=['test_login'])" ]
+  },
+  "source" : "dd7fa74e2935b20a.json",
+  "parameterValues" : [ ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/e425d3e0108cef57.json

+{
+  "uid" : "e425d3e0108cef57",
+  "name" : "反向用例-用户名正确,密码过短",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "f5ad8b2871fbe9131e812a7e7fd4507e",
+  "time" : {
+    "start" : 1716272598998,
+    "stop" : 1716272599093,
+    "duration" : 95
+  },
+  "status" : "passed",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "passed",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "27912ca823c311e6",
+      "name" : "log",
+      "source" : "27912ca823c311e6.txt",
+      "type" : "text/plain",
+      "size" : 276
+    }, {
+      "uid" : "c49546fe18c84daf",
+      "name" : "stdout",
+      "source" : "c49546fe18c84daf.txt",
+      "type" : "text/plain",
+      "size" : 7
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 2,
+    "shouldDisplayMessage" : false
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "认证接口"
+  }, {
+    "name" : "story",
+    "value" : "登录系统"
+  }, {
+    "name" : "severity",
+    "value" : "中"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'登录系统'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'username': 'admin', 'password': 'm'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'中'"
+  }, {
+    "name" : "case_title",
+    "value" : "'反向用例-用户名正确,密码过短'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '账号或密码错误'}"
+  }, {
+    "name" : "method",
+    "value" : "'POST'"
+  }, {
+    "name" : "mime",
+    "value" : "'application/json'"
+  }, {
+    "name" : "module_name",
+    "value" : "'认证接口'"
+  }, {
+    "name" : "sql_data",
+    "value" : "None"
+  }, {
+    "name" : "sql_type",
+    "value" : "None"
+  }, {
+    "name" : "update_key",
+    "value" : "None"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/auth'"
+  } ],
+  "links" : [ ],
+  "hidden" : false,
+  "retry" : false,
+  "extra" : {
+    "severity" : "normal",
+    "retries" : [ ],
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "e425d3e0108cef57.json",
+  "parameterValues" : [ "'登录系统'", "{'username': 'admin', 'password': 'm'}", "'中'", "'反向用例-用户名正确,密码过短'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/f0b29a97131b512d.json

+{
+  "uid" : "f0b29a97131b512d",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm",
+  "historyId" : "526f1fd519b78b4955668d6cfd277048",
+  "time" : {
+    "start" : 1716272642365,
+    "stop" : 1716272642541,
+    "duration" : 176
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "2a6299f399f58eb7",
+      "name" : "log",
+      "source" : "2a6299f399f58eb7.txt",
+      "type" : "text/plain",
+      "size" : 1989
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "组织管理"
+  }, {
+    "name" : "story",
+    "value" : "添加组织"
+  }, {
+    "name" : "severity",
+    "value" : "高"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-老张"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_mirZhang"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_mirZhang.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'添加组织'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'高'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '添加组织成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'POST'"
+  }, {
+    "name" : "mime",
+    "value" : "'json'"
+  }, {
+    "name" : "module_name",
+    "value" : "'组织管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}"
+  }, {
+    "name" : "sql_type",
+    "value" : "'select|delete'"
+  }, {
+    "name" : "update_key",
+    "value" : "'demId'"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/org/v1/org/addOrg'"
+  } ],
+  "links" : [ ],
+  "hidden" : true,
+  "retry" : true,
+  "extra" : {
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "f0b29a97131b512d.json",
+  "parameterValues" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/f63c130e44479e2f.json

+{
+  "uid" : "f63c130e44479e2f",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "487ae598a2b30a5ea2489bb3e5fa08a4",
+  "time" : {
+    "start" : 1716272617174,
+    "stop" : 1716272617355,
+    "duration" : 181
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "c03a0df9281574b5",
+      "name" : "log",
+      "source" : "c03a0df9281574b5.txt",
+      "type" : "text/plain",
+      "size" : 1591
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "组织管理"
+  }, {
+    "name" : "story",
+    "value" : "添加组织"
+  }, {
+    "name" : "severity",
+    "value" : "高"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'添加组织'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'高'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '添加组织成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'POST'"
+  }, {
+    "name" : "mime",
+    "value" : "'json'"
+  }, {
+    "name" : "module_name",
+    "value" : "'组织管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}"
+  }, {
+    "name" : "sql_type",
+    "value" : "'select|delete'"
+  }, {
+    "name" : "update_key",
+    "value" : "'demId'"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/org/v1/org/addOrg'"
+  } ],
+  "links" : [ ],
+  "hidden" : true,
+  "retry" : true,
+  "extra" : {
+    "categories" : [ ],
+    "tags" : [ ]
+  },
+  "source" : "f63c130e44479e2f.json",
+  "parameterValues" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/test-cases/f7e90e36deb68600.json

+{
+  "uid" : "f7e90e36deb68600",
+  "name" : "正向用例",
+  "fullName" : "test_case.test_demo.test_bpm.TestBPM#test_bpm",
+  "historyId" : "487ae598a2b30a5ea2489bb3e5fa08a4",
+  "time" : {
+    "start" : 1716272621599,
+    "stop" : 1716272621780,
+    "duration" : 181
+  },
+  "status" : "failed",
+  "statusMessage" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+  "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+  "flaky" : false,
+  "newFailed" : false,
+  "beforeStages" : [ ],
+  "testStage" : {
+    "status" : "failed",
+    "statusMessage" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+    "statusTrace" : "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError",
+    "steps" : [ ],
+    "attachments" : [ {
+      "uid" : "a6c92586b9cefbbf",
+      "name" : "log",
+      "source" : "a6c92586b9cefbbf.txt",
+      "type" : "text/plain",
+      "size" : 2387
+    } ],
+    "parameters" : [ ],
+    "hasContent" : true,
+    "stepsCount" : 0,
+    "attachmentsCount" : 1,
+    "shouldDisplayMessage" : true
+  },
+  "afterStages" : [ ],
+  "labels" : [ {
+    "name" : "feature",
+    "value" : "组织管理"
+  }, {
+    "name" : "story",
+    "value" : "添加组织"
+  }, {
+    "name" : "severity",
+    "value" : "高"
+  }, {
+    "name" : "epic",
+    "value" : "BPM系统-demo"
+  }, {
+    "name" : "parentSuite",
+    "value" : "test_case.test_demo"
+  }, {
+    "name" : "suite",
+    "value" : "test_bpm"
+  }, {
+    "name" : "subSuite",
+    "value" : "TestBPM"
+  }, {
+    "name" : "host",
+    "value" : "LAPTOP-O09782E1"
+  }, {
+    "name" : "thread",
+    "value" : "8968-MainThread"
+  }, {
+    "name" : "framework",
+    "value" : "pytest"
+  }, {
+    "name" : "language",
+    "value" : "cpython3"
+  }, {
+    "name" : "package",
+    "value" : "test_case.test_demo.test_bpm"
+  }, {
+    "name" : "resultFormat",
+    "value" : "allure2"
+  } ],
+  "parameters" : [ {
+    "name" : "api_name",
+    "value" : "'添加组织'"
+  }, {
+    "name" : "case_data",
+    "value" : "{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}"
+  }, {
+    "name" : "case_level",
+    "value" : "'高'"
+  }, {
+    "name" : "case_title",
+    "value" : "'正向用例'"
+  }, {
+    "name" : "expect_data",
+    "value" : "{'message': '添加组织成功'}"
+  }, {
+    "name" : "method",
+    "value" : "'POST'"
+  }, {
+    "name" : "mime",
+    "value" : "'json'"
+  }, {
+    "name" : "module_name",
+    "value" : "'组织管理'"
+  }, {
+    "name" : "sql_data",
+    "value" : "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}"
+  }, {
+    "name" : "sql_type",
+    "value" : "'select|delete'"
+  }, {
+    "name" : "update_key",
+    "value" : "'demId'"
+  }, {
+    "name" : "url",
+    "value" : "'http://120.46.172.186:8080/api/org/v1/org/addOrg'"
+  } ],
+  "links" : [ ],
+  "hidden" : false,
+  "retry" : false,
+  "extra" : {
+    "severity" : "normal",
+    "retries" : [ {
+      "uid" : "9d2f1604d71ec7a6",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+      "time" : {
+        "start" : 1716272619383,
+        "stop" : 1716272619564,
+        "duration" : 181
+      }
+    }, {
+      "uid" : "f63c130e44479e2f",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+      "time" : {
+        "start" : 1716272617174,
+        "stop" : 1716272617355,
+        "duration" : 181
+      }
+    }, {
+      "uid" : "209ce81276c337a6",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+      "time" : {
+        "start" : 1716272614968,
+        "stop" : 1716272615147,
+        "duration" : 179
+      }
+    }, {
+      "uid" : "47066bd5655ab306",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+      "time" : {
+        "start" : 1716272612750,
+        "stop" : 1716272612931,
+        "duration" : 181
+      }
+    }, {
+      "uid" : "682b7b7636aca843",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+      "time" : {
+        "start" : 1716272610542,
+        "stop" : 1716272610722,
+        "duration" : 180
+      }
+    } ],
+    "categories" : [ {
+      "name" : "Product defects",
+      "matchedStatuses" : [ ],
+      "flaky" : false
+    } ],
+    "tags" : [ ]
+  },
+  "source" : "f7e90e36deb68600.json",
+  "parameterValues" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/data/timeline.json

+{
+  "uid" : "ab17fc5a4eb3bca4b216b548c7f9fcbc",
+  "name" : "timeline",
+  "children" : [ {
+    "name" : "LAPTOP-O09782E1",
+    "children" : [ {
+      "name" : "8968-MainThread",
+      "children" : [ {
+        "name" : "test用例函数-依赖登录成功和添加维度成功",
+        "uid" : "7efd9dd32f98b518",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272633097,
+          "stop" : 1716272633098,
+          "duration" : 1
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "10e8cf966692af2d",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272621795,
+          "stop" : 1716272621848,
+          "duration" : 53
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'组织加入用户'", "{'orgCode': 'test_add_org', 'accounts': 'admin'}", "'高'", "'正向用例'", "{'state': True, 'message': '加入成功', 'value': ''}", "'POST'", "'query'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/orgUsers/addUsersForOrg'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "682b7b7636aca843",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272610542,
+          "stop" : 1716272610722,
+          "duration" : 180
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '需要更新', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "139913cc61e34bb9",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272610326,
+          "stop" : 1716272610382,
+          "duration" : 56
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'刷新token'", "None", "'中'", "'正向用例'", "{'message': '刷新token成功'}", "'GET'", "None", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/refresh'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "7af172a2303b627d",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272610398,
+          "stop" : 1716272610534,
+          "duration" : 136
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'添加维度'", "{'code': 'api_auto_test_add_dem', 'description': 'api_auto_test_add_dem', 'isDefault': 0, 'name': 'api_auto_test_add_dem'}", "'高'", "'正向用例'", "{'message': '添加维度成功！'}", "'pOst'", "'json'", "'维度管理'", "'delete FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'delete'", "None", "'http://120.46.172.186:8080/api/demension/v1/dem/addDem'" ]
+      }, {
+        "name" : "反向用例-用户名正确,密码为特殊字符",
+        "uid" : "d093b8587a3ab4f3",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272599103,
+          "stop" : 1716272599203,
+          "duration" : 100
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'登录系统'", "{'username': 'admin', 'password': '☯㍿卍卐'}", "'中'", "'反向用例-用户名正确,密码为特殊字符'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "adb4666aed6ea6fd",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272644756,
+          "stop" : 1716272644809,
+          "duration" : 53
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'组织加入用户'", "{'orgCode': 'test_add_org', 'accounts': 'admin'}", "'高'", "'正向用例'", "{'state': True, 'message': '加入成功', 'value': ''}", "'POST'", "'query'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/orgUsers/addUsersForOrg'" ]
+      }, {
+        "name" : "添加维度-依赖登录",
+        "uid" : "dd7fa74e2935b20a",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272632942,
+          "stop" : 1716272633094,
+          "duration" : 152
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "76ee0be7403e029e",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272644818,
+          "stop" : 1716272644873,
+          "duration" : 55
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'保存组织参数'", "{'query': {'orgCode': 'test_add_org'}, 'body': [{'alias': 'sz', 'value': 100}, {'alias': 'kc', 'value': '语文课'}]}", "'中'", "'正向用例'", "{'state': True, 'message': '保存组织参数成功！', 'value': ''}", "'post'", "'query|json'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/orgParam/saveOrgParams'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "b6d10bbf3ce5a604",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272644883,
+          "stop" : 1716272644938,
+          "duration" : 55
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'删除组织'", "'test_add_org'", "'高'", "'正向用例'", "{'state': True, 'message': '删除组织成功！', 'value': ''}", "'POST'", "'text/plain'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/org/deleteOrg'" ]
+      }, {
+        "name" : "反向用例-密码正确,用户名过长",
+        "uid" : "8142d41860b04b15",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272599315,
+          "stop" : 1716272599407,
+          "duration" : 92
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'登录系统'", "{'username': 'adminadminadminadmin', 'password': 'MTIzNDU2'}", "'中'", "'反向用例-密码正确,用户名过长'", "{'message': '账号或密码错误'}", "'POST'", "'json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "209ce81276c337a6",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272614968,
+          "stop" : 1716272615147,
+          "duration" : 179
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+      }, {
+        "name" : "正向用例-正确输入用户名和密码",
+        "uid" : "80142e22de024a60",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272598748,
+          "stop" : 1716272598811,
+          "duration" : 63
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'登录系统'", "{'username': 'admin', 'password': 'MTIzNDU2'}", "'高'", "'正向用例-正确输入用户名和密码'", "{'username': '超级管理员', 'loginStatus': True, 'account': 'admin'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "cc6c15cf3215c8cc",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272632686,
+          "stop" : 1716272632817,
+          "duration" : 131
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'根据维度编码删除维度'", "{'ids': '1792803379156631552'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "34d4a7d4229ac13b",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272644958,
+          "stop" : 1716272645054,
+          "duration" : 96
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'根据维度编码删除维度'", "{'ids': '需要更新'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "f7e90e36deb68600",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272621599,
+          "stop" : 1716272621780,
+          "duration" : 181
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "12eaadd487a58cd",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272649197,
+          "stop" : 1716272649328,
+          "duration" : 131
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'根据维度编码删除维度'", "{'ids': '1792803475629817856'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "c2d850dec3954142",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272604095,
+          "stop" : 1716272604145,
+          "duration" : 50
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'刷新token'", "None", "'中'", "'正向用例'", "{'message': '刷新token成功'}", "'GET'", "None", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/refresh'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "18d9dd9447f5bd7b",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272599755,
+          "stop" : 1716272599845,
+          "duration" : 90
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'刷新token'", "None", "'中'", "'正向用例'", "{'message': '刷新token成功'}", "'GET'", "None", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/refresh'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "6bce7862e8bf2a3f",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272655685,
+          "stop" : 1716272655817,
+          "duration" : 132
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'根据维度编码删除维度'", "{'ids': '1792803475629817856'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "272c438f0bed80b",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272608243,
+          "stop" : 1716272608294,
+          "duration" : 51
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'刷新token'", "None", "'中'", "'正向用例'", "{'message': '刷新token成功'}", "'GET'", "None", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/refresh'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "63fd0603d3fc3e68",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272647081,
+          "stop" : 1716272647173,
+          "duration" : 92
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'根据维度编码删除维度'", "{'ids': '1792803475629817856'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "d86d7ab21b67c470",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272635752,
+          "stop" : 1716272635930,
+          "duration" : 178
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "bab371eff6794f2b",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272637956,
+          "stop" : 1716272638139,
+          "duration" : 183
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+      }, {
+        "name" : "反向用例-密码正确,用户名错误",
+        "uid" : "a0b87df8f50dc316",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272599640,
+          "stop" : 1716272599737,
+          "duration" : 97
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'登录系统'", "{'username': 'admin123', 'password': 'MTIzNDU2'}", "'中'", "'反向用例-密码正确,用户名错误'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+      }, {
+        "name" : "反向用例-用户名正确,密码过短",
+        "uid" : "e425d3e0108cef57",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272598998,
+          "stop" : 1716272599093,
+          "duration" : 95
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'登录系统'", "{'username': 'admin', 'password': 'm'}", "'中'", "'反向用例-用户名正确,密码过短'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "5dd7bd33a0896cb1",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272653523,
+          "stop" : 1716272653661,
+          "duration" : 138
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'根据维度编码删除维度'", "{'ids': '1792803475629817856'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "15e35cc79ee68b8c",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272621856,
+          "stop" : 1716272621912,
+          "duration" : 56
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'保存组织参数'", "{'query': {'orgCode': 'test_add_org'}, 'body': [{'alias': 'sz', 'value': 100}, {'alias': 'kc', 'value': '语文课'}]}", "'中'", "'正向用例'", "{'state': True, 'message': '保存组织参数成功！', 'value': ''}", "'post'", "'query|json'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/orgParam/saveOrgParams'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "510c89b87f6352b8",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272633398,
+          "stop" : 1716272633535,
+          "duration" : 137
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'添加维度'", "{'code': 'api_auto_test_add_dem', 'description': 'api_auto_test_add_dem', 'isDefault': 0, 'name': 'api_auto_test_add_dem'}", "'高'", "'正向用例'", "{'message': '添加维度成功！'}", "'pOst'", "'json'", "'维度管理'", "'delete FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'delete'", "None", "'http://120.46.172.186:8080/api/demension/v1/dem/addDem'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "64c7a0a97adde6d1",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272630526,
+          "stop" : 1716272630660,
+          "duration" : 134
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'根据维度编码删除维度'", "{'ids': '1792803379156631552'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "d386a81c173e63a4",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272633544,
+          "stop" : 1716272633720,
+          "duration" : 176
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '需要更新', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "f63c130e44479e2f",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272617174,
+          "stop" : 1716272617355,
+          "duration" : 181
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "643ca7629b09152b",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272644557,
+          "stop" : 1716272644742,
+          "duration" : 185
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+      }, {
+        "name" : "反向用例-用户名正确,密码为空",
+        "uid" : "1bd3c031f056ab2e",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272598829,
+          "stop" : 1716272598886,
+          "duration" : 57
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'登录系统'", "{'username': 'admin', 'password': ''}", "'中'", "'反向用例-用户名正确,密码为空'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "4cf6104851f97da",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272602024,
+          "stop" : 1716272602074,
+          "duration" : 50
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'刷新token'", "None", "'中'", "'正向用例'", "{'message': '刷新token成功'}", "'GET'", "None", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/refresh'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "9a2316575f97b91e",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272621920,
+          "stop" : 1716272621978,
+          "duration" : 58
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'删除组织'", "'test_add_org'", "'高'", "'正向用例'", "{'state': True, 'message': '删除组织成功！', 'value': ''}", "'POST'", "'text/plain'", "'组织管理'", "None", "None", "None", "'http://120.46.172.186:8080/api/org/v1/org/deleteOrg'" ]
+      }, {
+        "name" : "反向用例-密码正确,用户名为空",
+        "uid" : "5532c9175fb2354e",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272599213,
+          "stop" : 1716272599306,
+          "duration" : 93
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'登录系统'", "{'username': '', 'password': 'MTIzNDU2'}", "'中'", "'反向用例-密码正确,用户名为空'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+      }, {
+        "name" : "反向用例-密码正确,用户名为特殊字符",
+        "uid" : "5b0b595f880fe013",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272599527,
+          "stop" : 1716272599627,
+          "duration" : 100
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'登录系统'", "{'username': '☯㍿卍卐', 'password': 'MTIzNDU2'}", "'中'", "'反向用例-密码正确,用户名为特殊字符'", "{'message': '账号或密码错误'}", "'POST'", "'json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "4f1ef4a5b7fd035f",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272606164,
+          "stop" : 1716272606215,
+          "duration" : 51
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'刷新token'", "None", "'中'", "'正向用例'", "{'message': '刷新token成功'}", "'GET'", "None", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/refresh'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "88e60d865858edc2",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272624099,
+          "stop" : 1716272624187,
+          "duration" : 88
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'根据维度编码删除维度'", "{'ids': '1792803379156631552'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "f0b29a97131b512d",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272642365,
+          "stop" : 1716272642541,
+          "duration" : 176
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "3015128a124f9ae6",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272640167,
+          "stop" : 1716272640342,
+          "duration" : 175
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "9d2f1604d71ec7a6",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272619383,
+          "stop" : 1716272619564,
+          "duration" : 181
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "b477169fbff4410e",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272621987,
+          "stop" : 1716272622080,
+          "duration" : 93
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'根据维度编码删除维度'", "{'ids': '需要更新'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "d1e0d7501f9ea60",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272628366,
+          "stop" : 1716272628501,
+          "duration" : 135
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'根据维度编码删除维度'", "{'ids': '1792803379156631552'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+      }, {
+        "name" : "反向用例-用户名正确,密码过长",
+        "uid" : "c26c17d72f28aa7f",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272598895,
+          "stop" : 1716272598989,
+          "duration" : 94
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'登录系统'", "{'username': 'admin', 'password': 'MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2'}", "'中'", "'反向用例-用户名正确,密码过长'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "1ad3f99f8aec3b78",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272651358,
+          "stop" : 1716272651491,
+          "duration" : 133
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'根据维度编码删除维度'", "{'ids': '1792803475629817856'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "47066bd5655ab306",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272612750,
+          "stop" : 1716272612931,
+          "duration" : 181
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'添加组织'", "{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}", "'高'", "'正向用例'", "{'message': '添加组织成功'}", "'POST'", "'json'", "'组织管理'", "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}", "'select|delete'", "'demId'", "'http://120.46.172.186:8080/api/org/v1/org/addOrg'" ]
+      }, {
+        "name" : "登录--前置",
+        "uid" : "ce412b2b5e44b608",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272632845,
+          "stop" : 1716272632940,
+          "duration" : 95
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ ]
+      }, {
+        "name" : "正向用例",
+        "uid" : "a011264732c293ec",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "failed",
+        "time" : {
+          "start" : 1716272626207,
+          "stop" : 1716272626341,
+          "duration" : 134
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'根据维度编码删除维度'", "{'ids': '1792803379156631552'}", "'中'", "'正向用例'", "{'message': '删除维度成功'}", "'DELETE'", "'query'", "'维度管理'", "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'", "'select'", "'ids'", "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'" ]
+      }, {
+        "name" : "反向用例-密码正确,用户名过短",
+        "uid" : "96596e0fab9d3415",
+        "parentUid" : "e4a707af5684e391a4553cf4ade23b8f",
+        "status" : "passed",
+        "time" : {
+          "start" : 1716272599418,
+          "stop" : 1716272599517,
+          "duration" : 99
+        },
+        "flaky" : false,
+        "newFailed" : false,
+        "parameters" : [ "'登录系统'", "{'username': 'a', 'password': 'MTIzNDU2'}", "'中'", "'反向用例-密码正确,用户名过短'", "{'message': '账号或密码错误'}", "'POST'", "'application/json'", "'认证接口'", "None", "None", "None", "'http://120.46.172.186:8080/auth'" ]
+      } ],
+      "uid" : "e4a707af5684e391a4553cf4ade23b8f"
+    } ],
+    "uid" : "7e33cee26d6ca920df2dc9409741f061"
+  } ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/export/influxDbData.txt

+launch_status failed=5 1716272796000000000
+launch_status broken=0 1716272796000000000
+launch_status passed=21 1716272796000000000
+launch_status skipped=0 1716272796000000000
+launch_status unknown=0 1716272796000000000
+launch_time duration=57069 1716272796000000000
+launch_time min_duration=1 1716272796000000000
+launch_time max_duration=185 1716272796000000000
+launch_time sum_duration=2426 1716272796000000000
+launch_problems product_defects=5 1716272796000000000
+launch_retries retries=25 1716272796000000000
+launch_retries run=26 1716272796000000000

InterfaceAutoTest/report/allure/html/export/mail.html

+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="utf-8">
+    <title>Allure Report summary mail</title>
+</head>
+<body>
+    Mail body
+</body>
+</html>

InterfaceAutoTest/report/allure/html/export/prometheusData.txt

+launch_status_failed 5
+launch_status_broken 0
+launch_status_passed 21
+launch_status_skipped 0
+launch_status_unknown 0
+launch_time_duration 57069
+launch_time_min_duration 1
+launch_time_max_duration 185
+launch_time_sum_duration 2426
+launch_problems_product_defects 5
+launch_retries_retries 25
+launch_retries_run 26

InterfaceAutoTest/report/allure/html/favicon.ico

+module.exports = __webpack_public_path__ + "favicon.ico";
\ No newline at end of file

InterfaceAutoTest/report/allure/html/history/categories-trend.json

+[ {
+  "data" : {
+    "Product defects" : 5
+  }
+} ]
\ No newline at end of file

InterfaceAutoTest/report/allure/html/history/duration-trend.json

+[ {
+  "data" : {
+    "duration" : 57069
+  }
+} ]
\ No newline at end of file

InterfaceAutoTest/report/allure/html/history/history-trend.json

+[ {
+  "data" : {
+    "failed" : 5,
+    "broken" : 0,
+    "skipped" : 0,
+    "passed" : 21,
+    "unknown" : 0,
+    "total" : 26
+  }
+} ]
\ No newline at end of file

InterfaceAutoTest/report/allure/html/history/history.json

+{
+  "83d67cdc5550a580709b5379b214757d" : {
+    "statistic" : {
+      "failed" : 0,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 1,
+      "unknown" : 0,
+      "total" : 1
+    },
+    "items" : [ {
+      "uid" : "a0b87df8f50dc316",
+      "status" : "passed",
+      "time" : {
+        "start" : 1716272599640,
+        "stop" : 1716272599737,
+        "duration" : 97
+      }
+    } ]
+  },
+  "45fbe766301d5f34f2314154dd48ad7c" : {
+    "statistic" : {
+      "failed" : 0,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 1,
+      "unknown" : 0,
+      "total" : 1
+    },
+    "items" : [ {
+      "uid" : "d093b8587a3ab4f3",
+      "status" : "passed",
+      "time" : {
+        "start" : 1716272599103,
+        "stop" : 1716272599203,
+        "duration" : 100
+      }
+    } ]
+  },
+  "526f1fd519b78b4955668d6cfd277048" : {
+    "statistic" : {
+      "failed" : 1,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 0,
+      "unknown" : 0,
+      "total" : 1
+    },
+    "items" : [ {
+      "uid" : "643ca7629b09152b",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+      "time" : {
+        "start" : 1716272644557,
+        "stop" : 1716272644742,
+        "duration" : 185
+      }
+    } ]
+  },
+  "2d767e403ea75ccb1f14fcd976c25353" : {
+    "statistic" : {
+      "failed" : 0,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 1,
+      "unknown" : 0,
+      "total" : 1
+    },
+    "items" : [ {
+      "uid" : "adb4666aed6ea6fd",
+      "status" : "passed",
+      "time" : {
+        "start" : 1716272644756,
+        "stop" : 1716272644809,
+        "duration" : 53
+      }
+    } ]
+  },
+  "1dcae5f805bddffd6ce19e14c8b3458b" : {
+    "statistic" : {
+      "failed" : 1,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 0,
+      "unknown" : 0,
+      "total" : 1
+    },
+    "items" : [ {
+      "uid" : "139913cc61e34bb9",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '刷新token成功' == None\n +  where None = <built-in method get of dict object at 0x0000014F191C40C0>('message')\n +    where <built-in method get of dict object at 0x0000014F191C40C0> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwOH0.LsIqI6NBfMYmLfeFQHaiE3TLchmrNO9P3P92GkiuQQoiDTEXfelTGerbpaF-Qp4K4_45jG2cACLNB8dNwS0m-w', 'userAttrs': {}, ...}.get\n +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwOH0.LsIqI6NBfMYmLfeFQHaiE3TLchmrNO9P3P92GkiuQQoiDTEXfelTGerbpaF-Qp4K4_45jG2cACLNB8dNwS0m-w', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\n +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json",
+      "time" : {
+        "start" : 1716272610326,
+        "stop" : 1716272610382,
+        "duration" : 56
+      }
+    } ]
+  },
+  "385bda31fe152e15cd1fc6b7817225aa" : {
+    "statistic" : {
+      "failed" : 0,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 1,
+      "unknown" : 0,
+      "total" : 1
+    },
+    "items" : [ {
+      "uid" : "10e8cf966692af2d",
+      "status" : "passed",
+      "time" : {
+        "start" : 1716272621795,
+        "stop" : 1716272621848,
+        "duration" : 53
+      }
+    } ]
+  },
+  "435ba53246b35b4af7286c32ad75fe23" : {
+    "statistic" : {
+      "failed" : 0,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 1,
+      "unknown" : 0,
+      "total" : 1
+    },
+    "items" : [ {
+      "uid" : "7af172a2303b627d",
+      "status" : "passed",
+      "time" : {
+        "start" : 1716272610398,
+        "stop" : 1716272610534,
+        "duration" : 136
+      }
+    } ]
+  },
+  "f7417fae3641334c555177156c21126d" : {
+    "statistic" : {
+      "failed" : 0,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 1,
+      "unknown" : 0,
+      "total" : 1
+    },
+    "items" : [ {
+      "uid" : "80142e22de024a60",
+      "status" : "passed",
+      "time" : {
+        "start" : 1716272598748,
+        "stop" : 1716272598811,
+        "duration" : 63
+      }
+    } ]
+  },
+  "aab084bf6a05ec45b335f51ecc264b7e" : {
+    "statistic" : {
+      "failed" : 0,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 1,
+      "unknown" : 0,
+      "total" : 1
+    },
+    "items" : [ {
+      "uid" : "510c89b87f6352b8",
+      "status" : "passed",
+      "time" : {
+        "start" : 1716272633398,
+        "stop" : 1716272633535,
+        "duration" : 137
+      }
+    } ]
+  },
+  "f5ad8b2871fbe9131e812a7e7fd4507e" : {
+    "statistic" : {
+      "failed" : 0,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 1,
+      "unknown" : 0,
+      "total" : 1
+    },
+    "items" : [ {
+      "uid" : "e425d3e0108cef57",
+      "status" : "passed",
+      "time" : {
+        "start" : 1716272598998,
+        "stop" : 1716272599093,
+        "duration" : 95
+      }
+    } ]
+  },
+  "db26a6f22fbc123482ea90d3e77fa9fd" : {
+    "statistic" : {
+      "failed" : 0,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 1,
+      "unknown" : 0,
+      "total" : 1
+    },
+    "items" : [ {
+      "uid" : "9a2316575f97b91e",
+      "status" : "passed",
+      "time" : {
+        "start" : 1716272621920,
+        "stop" : 1716272621978,
+        "duration" : 58
+      }
+    } ]
+  },
+  "487ae598a2b30a5ea2489bb3e5fa08a4" : {
+    "statistic" : {
+      "failed" : 1,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 0,
+      "unknown" : 0,
+      "total" : 1
+    },
+    "items" : [ {
+      "uid" : "f7e90e36deb68600",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功",
+      "time" : {
+        "start" : 1716272621599,
+        "stop" : 1716272621780,
+        "duration" : 181
+      }
+    } ]
+  },
+  "4164dfc118ea6cc8eeb9ce3984609436" : {
+    "statistic" : {
+      "failed" : 0,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 1,
+      "unknown" : 0,
+      "total" : 1
+    },
+    "items" : [ {
+      "uid" : "1bd3c031f056ab2e",
+      "status" : "passed",
+      "time" : {
+        "start" : 1716272598829,
+        "stop" : 1716272598886,
+        "duration" : 57
+      }
+    } ]
+  },
+  "347d2f73ed73495ba7ba72dbf723f253" : {
+    "statistic" : {
+      "failed" : 1,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 0,
+      "unknown" : 0,
+      "total" : 1
+    },
+    "items" : [ {
+      "uid" : "cc6c15cf3215c8cc",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+      "time" : {
+        "start" : 1716272632686,
+        "stop" : 1716272632817,
+        "duration" : 131
+      }
+    } ]
+  },
+  "fa305c7b3d900250c6115572baa5540a" : {
+    "statistic" : {
+      "failed" : 0,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 1,
+      "unknown" : 0,
+      "total" : 1
+    },
+    "items" : [ {
+      "uid" : "5b0b595f880fe013",
+      "status" : "passed",
+      "time" : {
+        "start" : 1716272599527,
+        "stop" : 1716272599627,
+        "duration" : 100
+      }
+    } ]
+  },
+  "968bf5f1bc5266807075e84dfd49d322" : {
+    "statistic" : {
+      "failed" : 0,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 1,
+      "unknown" : 0,
+      "total" : 1
+    },
+    "items" : [ {
+      "uid" : "8142d41860b04b15",
+      "status" : "passed",
+      "time" : {
+        "start" : 1716272599315,
+        "stop" : 1716272599407,
+        "duration" : 92
+      }
+    } ]
+  },
+  "ca39ba3d830745ef2c54de45a0fd94de" : {
+    "statistic" : {
+      "failed" : 0,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 1,
+      "unknown" : 0,
+      "total" : 1
+    },
+    "items" : [ {
+      "uid" : "5532c9175fb2354e",
+      "status" : "passed",
+      "time" : {
+        "start" : 1716272599213,
+        "stop" : 1716272599306,
+        "duration" : 93
+      }
+    } ]
+  },
+  "2c19ea97cbbe4cb31079c2ee05828120" : {
+    "statistic" : {
+      "failed" : 0,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 1,
+      "unknown" : 0,
+      "total" : 1
+    },
+    "items" : [ {
+      "uid" : "dd7fa74e2935b20a",
+      "status" : "passed",
+      "time" : {
+        "start" : 1716272632942,
+        "stop" : 1716272633094,
+        "duration" : 152
+      }
+    } ]
+  },
+  "f0f670cbfec7a9680aec241c756307a6" : {
+    "statistic" : {
+      "failed" : 1,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 0,
+      "unknown" : 0,
+      "total" : 1
+    },
+    "items" : [ {
+      "uid" : "6bce7862e8bf2a3f",
+      "status" : "failed",
+      "statusDetails" : "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功",
+      "time" : {
+        "start" : 1716272655685,
+        "stop" : 1716272655817,
+        "duration" : 132
+      }
+    } ]
+  },
+  "5ee7a985530eff8db65cbc3fbd8fd151" : {
+    "statistic" : {
+      "failed" : 0,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 1,
+      "unknown" : 0,
+      "total" : 1
+    },
+    "items" : [ {
+      "uid" : "b6d10bbf3ce5a604",
+      "status" : "passed",
+      "time" : {
+        "start" : 1716272644883,
+        "stop" : 1716272644938,
+        "duration" : 55
+      }
+    } ]
+  },
+  "e133082949e07d38e4a8587843153535" : {
+    "statistic" : {
+      "failed" : 0,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 1,
+      "unknown" : 0,
+      "total" : 1
+    },
+    "items" : [ {
+      "uid" : "15e35cc79ee68b8c",
+      "status" : "passed",
+      "time" : {
+        "start" : 1716272621856,
+        "stop" : 1716272621912,
+        "duration" : 56
+      }
+    } ]
+  },
+  "112831bd8b103ba5270ea46bde2822af" : {
+    "statistic" : {
+      "failed" : 0,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 1,
+      "unknown" : 0,
+      "total" : 1
+    },
+    "items" : [ {
+      "uid" : "7efd9dd32f98b518",
+      "status" : "passed",
+      "time" : {
+        "start" : 1716272633097,
+        "stop" : 1716272633098,
+        "duration" : 1
+      }
+    } ]
+  },
+  "37bde76add67e3f73e804e1ff293bbd9" : {
+    "statistic" : {
+      "failed" : 0,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 1,
+      "unknown" : 0,
+      "total" : 1
+    },
+    "items" : [ {
+      "uid" : "c26c17d72f28aa7f",
+      "status" : "passed",
+      "time" : {
+        "start" : 1716272598895,
+        "stop" : 1716272598989,
+        "duration" : 94
+      }
+    } ]
+  },
+  "b3ea99bce5fbf89dc61e67ffc74d2796" : {
+    "statistic" : {
+      "failed" : 0,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 1,
+      "unknown" : 0,
+      "total" : 1
+    },
+    "items" : [ {
+      "uid" : "ce412b2b5e44b608",
+      "status" : "passed",
+      "time" : {
+        "start" : 1716272632845,
+        "stop" : 1716272632940,
+        "duration" : 95
+      }
+    } ]
+  },
+  "f523c6add46569d79b9a33cc763be891" : {
+    "statistic" : {
+      "failed" : 0,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 1,
+      "unknown" : 0,
+      "total" : 1
+    },
+    "items" : [ {
+      "uid" : "76ee0be7403e029e",
+      "status" : "passed",
+      "time" : {
+        "start" : 1716272644818,
+        "stop" : 1716272644873,
+        "duration" : 55
+      }
+    } ]
+  },
+  "1a3971dd942170d7f7bcf2c1f2eecd8f" : {
+    "statistic" : {
+      "failed" : 0,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 1,
+      "unknown" : 0,
+      "total" : 1
+    },
+    "items" : [ {
+      "uid" : "96596e0fab9d3415",
+      "status" : "passed",
+      "time" : {
+        "start" : 1716272599418,
+        "stop" : 1716272599517,
+        "duration" : 99
+      }
+    } ]
+  }
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/history/retry-trend.json

+[ {
+  "data" : {
+    "run" : 26,
+    "retry" : 25
+  }
+} ]
\ No newline at end of file

InterfaceAutoTest/report/allure/html/index.html

+<!DOCTYPE html>
+<html dir="ltr">
+<head>
+    <meta charset="utf-8">
+    <title>Allure Report</title>
+    <link rel="favicon" href="favicon.ico?v=2">
+    <link rel="stylesheet" href="styles.css">
+                <link rel="stylesheet" href="plugins/screen-diff/styles.css">
+</head>
+<body>
+<div id="alert"></div>
+<div id="content">
+    <span class="spinner">
+        <span class="spinner__circle"></span>
+    </span>
+</div>
+<div id="popup"></div>
+<script src="app.js"></script>
+    <script src="plugins/behaviors/index.js"></script>
+    <script src="plugins/packages/index.js"></script>
+    <script src="plugins/screen-diff/index.js"></script>
+</body>
+</html>

InterfaceAutoTest/report/allure/html/plugins/behaviors/index.js

+'use strict';
+
+allure.api.addTranslation('en', {
+    tab: {
+        behaviors: {
+            name: 'Behaviors'
+        }
+    },
+    widget: {
+        behaviors: {
+            name: 'Features by stories',
+            showAll: 'show all'
+        }
+    }
+});
+
+allure.api.addTranslation('ru', {
+    tab: {
+        behaviors: {
+            name: 'Функциональность'
+        }
+    },
+    widget: {
+        behaviors: {
+            name: 'Функциональность',
+            showAll: 'показать все'
+        }
+    }
+});
+
+allure.api.addTranslation('zh', {
+    tab: {
+        behaviors: {
+            name: '功能'
+        }
+    },
+    widget: {
+        behaviors: {
+            name: '特性场景',
+            showAll: '显示所有'
+        }
+    }
+});
+
+allure.api.addTranslation('de', {
+    tab: {
+        behaviors: {
+            name: 'Verhalten'
+        }
+    },
+    widget: {
+        behaviors: {
+            name: 'Features nach Stories',
+            showAll: 'Zeige alle'
+        }
+    }
+});
+
+allure.api.addTranslation('nl', {
+    tab: {
+        behaviors: {
+            name: 'Functionaliteit'
+        }
+    },
+    widget: {
+        behaviors: {
+            name: 'Features en story’s',
+            showAll: 'Toon alle'
+        }
+    }
+});
+
+allure.api.addTranslation('he', {
+    tab: {
+        behaviors: {
+            name: 'התנהגויות'
+        }
+    },
+    widget: {
+        behaviors: {
+            name: 'תכונות לפי סיפורי משתמש',
+            showAll: 'הצג הכול'
+        }
+    }
+});
+
+allure.api.addTranslation('br', {
+    tab: {
+        behaviors: {
+            name: 'Comportamentos'
+        }
+    },
+    widget: {
+        behaviors: {
+            name: 'Funcionalidades por história',
+            showAll: 'Mostrar tudo'
+        }
+    }
+});
+
+allure.api.addTranslation('ja', {
+    tab: {
+        behaviors: {
+            name: '振る舞い'
+        }
+    },
+    widget: {
+        behaviors: {
+            name: 'ストーリー別の機能',
+            showAll: '全て表示'
+        }
+    }
+});
+
+allure.api.addTranslation('es', {
+    tab: {
+        behaviors: {
+            name: 'Funcionalidades'
+        }
+    },
+    widget: {
+        behaviors: {
+            name: 'Funcionalidades por Historias de Usuario',
+            showAll: 'mostrar todo'
+        }
+    }
+});
+
+allure.api.addTranslation('kr', {
+    tab: {
+        behaviors: {
+            name: '동작'
+        }
+    },
+    widget: {
+        behaviors: {
+            name: '스토리별 기능',
+            showAll: '전체 보기'
+        }
+    }
+});
+
+allure.api.addTranslation('fr', {
+    tab: {
+        behaviors: {
+            name: 'Comportements'
+        }
+    },
+    widget: {
+        behaviors: {
+            name: 'Thèmes par histoires',
+            showAll: 'Montrer tout'
+        }
+    }
+});
+
+allure.api.addTab('behaviors', {
+    title: 'tab.behaviors.name', icon: 'fa fa-list',
+    route: 'behaviors(/)(:testGroup)(/)(:testResult)(/)(:testResultTab)(/)',
+    onEnter: (function (testGroup, testResult, testResultTab) {
+        return new allure.components.TreeLayout({
+            testGroup: testGroup,
+            testResult: testResult,
+            testResultTab: testResultTab,
+            tabName: 'tab.behaviors.name',
+            baseUrl: 'behaviors',
+            url: 'data/behaviors.json',
+            csvUrl: 'data/behaviors.csv'
+        });
+    })
+});
+
+allure.api.addWidget('widgets', 'behaviors', allure.components.WidgetStatusView.extend({
+    rowTag: 'a',
+    title: 'widget.behaviors.name',
+    baseUrl: 'behaviors',
+    showLinks: true
+}));

InterfaceAutoTest/report/allure/html/plugins/packages/index.js

+'use strict';
+
+allure.api.addTranslation('en', {
+    tab: {
+        packages: {
+            name: 'Packages'
+        }
+    }
+});
+
+allure.api.addTranslation('ru', {
+    tab: {
+        packages: {
+            name: 'Пакеты'
+        }
+    }
+});
+
+allure.api.addTranslation('zh', {
+    tab: {
+        packages: {
+            name: '包'
+        }
+    }
+});
+
+allure.api.addTranslation('de', {
+    tab: {
+        packages: {
+            name: 'Pakete'
+        }
+    }
+});
+
+allure.api.addTranslation('nl', {
+    tab: {
+        packages: {
+            name: 'Packages'
+        }
+    }
+});
+
+allure.api.addTranslation('he', {
+    tab: {
+        packages: {
+            name: 'חבילות'
+        }
+    }
+});
+
+allure.api.addTranslation('br', {
+    tab: {
+        packages: {
+            name: 'Pacotes'
+        }
+    }
+});
+
+allure.api.addTranslation('ja', {
+    tab: {
+        packages: {
+            name: 'パッケージ'
+        }
+    }
+});
+
+allure.api.addTranslation('es', {
+    tab: {
+        packages: {
+            name: 'Paquetes'
+        }
+    }
+});
+
+allure.api.addTranslation('kr', {
+    tab: {
+        packages: {
+            name: '패키지'
+        }
+    }
+});
+
+allure.api.addTranslation('fr', {
+    tab: {
+        packages: {
+            name: 'Paquets'
+        }
+    }
+});
+
+allure.api.addTab('packages', {
+    title: 'tab.packages.name', icon: 'fa fa-align-left',
+    route: 'packages(/)(:testGroup)(/)(:testResult)(/)(:testResultTab)(/)',
+    onEnter: (function (testGroup, testResult, testResultTab) {
+        return new allure.components.TreeLayout({
+            testGroup: testGroup,
+            testResult: testResult,
+            testResultTab: testResultTab,
+            tabName: 'tab.packages.name',
+            baseUrl: 'packages',
+            url: 'data/packages.json'
+        });
+    })
+});

InterfaceAutoTest/report/allure/html/plugins/screen-diff/index.js

+(function () {
+    var settings = allure.getPluginSettings('screen-diff', { diffType: 'diff' });
+
+    function renderImage(src) {
+        return (
+            '<div class="screen-diff__container">' +
+            '<img class="screen-diff__image" src="' +
+            src +
+            '">' +
+            '</div>'
+        );
+    }
+
+    function findImage(data, name) {
+        if (data.testStage && data.testStage.attachments) {
+            var matchedImage = data.testStage.attachments.filter(function (attachment) {
+                return attachment.name === name;
+            })[0];
+            if (matchedImage) {
+                return 'data/attachments/' + matchedImage.source;
+            }
+        }
+        return null;
+    }
+
+    function renderDiffContent(type, diffImage, actualImage, expectedImage) {
+        if (type === 'diff') {
+            if (diffImage) {
+                return renderImage(diffImage);
+            }
+        }
+        if (type === 'overlay' && expectedImage) {
+            return (
+                '<div class="screen-diff__overlay screen-diff__container">' +
+                '<img class="screen-diff__image" src="' +
+                expectedImage +
+                '">' +
+                '<div class="screen-diff__image-over">' +
+                '<img class="screen-diff__image" src="' +
+                actualImage +
+                '">' +
+                '</div>' +
+                '</div>'
+            );
+        }
+        if (actualImage) {
+            return renderImage(actualImage);
+        }
+        return 'No diff data provided';
+    }
+
+    var TestResultView = Backbone.Marionette.View.extend({
+        regions: {
+            subView: '.screen-diff-view',
+        },
+        template: function () {
+            return '<div class="screen-diff-view"></div>';
+        },
+        onRender: function () {
+            var data = this.model.toJSON();
+            var testType = data.labels.filter(function (label) {
+                return label.name === 'testType';
+            })[0];
+            var diffImage = findImage(data, 'diff');
+            var actualImage = findImage(data, 'actual');
+            var expectedImage = findImage(data, 'expected');
+            if (!testType || testType.value !== 'screenshotDiff') {
+                return;
+            }
+            this.showChildView(
+                'subView',
+                new ScreenDiffView({
+                    diffImage: diffImage,
+                    actualImage: actualImage,
+                    expectedImage: expectedImage,
+                }),
+            );
+        },
+    });
+    var ErrorView = Backbone.Marionette.View.extend({
+        templateContext: function () {
+            return this.options;
+        },
+        template: function (data) {
+            return '<pre class="screen-diff-error">' + data.error + '</pre>';
+        },
+    });
+    var AttachmentView = Backbone.Marionette.View.extend({
+        regions: {
+            subView: '.screen-diff-view',
+        },
+        template: function () {
+            return '<div class="screen-diff-view"></div>';
+        },
+        onRender: function () {
+            jQuery
+                .getJSON(this.options.sourceUrl)
+                .then(this.renderScreenDiffView.bind(this), this.renderErrorView.bind(this));
+        },
+        renderErrorView: function (error) {
+            console.log(error);
+            this.showChildView(
+                'subView',
+                new ErrorView({
+                    error: error.statusText,
+                }),
+            );
+        },
+        renderScreenDiffView: function (data) {
+            this.showChildView(
+                'subView',
+                new ScreenDiffView({
+                    diffImage: data.diff,
+                    actualImage: data.actual,
+                    expectedImage: data.expected,
+                }),
+            );
+        },
+    });
+
+    var ScreenDiffView = Backbone.Marionette.View.extend({
+        className: 'pane__section',
+        events: function () {
+            return {
+                ['click [name="screen-diff-type-' + this.cid + '"]']: 'onDiffTypeChange',
+                'mousemove .screen-diff__overlay': 'onOverlayMove',
+            };
+        },
+        initialize: function (options) {
+            this.diffImage = options.diffImage;
+            this.actualImage = options.actualImage;
+            this.expectedImage = options.expectedImage;
+            this.radioName = 'screen-diff-type-' + this.cid;
+        },
+        templateContext: function () {
+            return {
+                diffType: settings.get('diffType'),
+                diffImage: this.diffImage,
+                actualImage: this.actualImage,
+                expectedImage: this.expectedImage,
+                radioName: this.radioName,
+            };
+        },
+        template: function (data) {
+            if (!data.diffImage && !data.actualImage && !data.expectedImage) {
+                return '';
+            }
+
+            return (
+                '<h3 class="pane__section-title">Screen Diff</h3>' +
+                '<div class="screen-diff__content">' +
+                '<div class="screen-diff__switchers">' +
+                '<label><input type="radio" name="' +
+                data.radioName +
+                '" value="diff"> Show diff</label>' +
+                '<label><input type="radio" name="' +
+                data.radioName +
+                '" value="overlay"> Show overlay</label>' +
+                '</div>' +
+                renderDiffContent(
+                    data.diffType,
+                    data.diffImage,
+                    data.actualImage,
+                    data.expectedImage,
+                ) +
+                '</div>'
+            );
+        },
+        adjustImageSize: function (event) {
+            var overImage = this.$(event.target);
+            overImage.width(overImage.width());
+        },
+        onRender: function () {
+            const diffType = settings.get('diffType');
+            this.$('[name="' + this.radioName + '"][value="' + diffType + '"]').prop(
+                'checked',
+                true,
+            );
+            if (diffType === 'overlay') {
+                this.$('.screen-diff__image-over img').on('load', this.adjustImageSize.bind(this));
+            }
+        },
+        onOverlayMove: function (event) {
+            var pageX = event.pageX;
+            var containerScroll = this.$('.screen-diff__container').scrollLeft();
+            var elementX = event.currentTarget.getBoundingClientRect().left;
+            var delta = pageX - elementX + containerScroll;
+            this.$('.screen-diff__image-over').width(delta);
+        },
+        onDiffTypeChange: function (event) {
+            settings.save('diffType', event.target.value);
+            this.render();
+        },
+    });
+    allure.api.addTestResultBlock(TestResultView, { position: 'before' });
+    allure.api.addAttachmentViewer('application/vnd.allure.image.diff', {
+        View: AttachmentView,
+        icon: 'fa fa-exchange',
+    });
+})();

InterfaceAutoTest/report/allure/html/plugins/screen-diff/styles.css

+.screen-diff__switchers {
+  margin-bottom: 1em;
+}
+
+.screen-diff__switchers label + label {
+  margin-left: 1em;
+}
+
+.screen-diff__overlay {
+  position: relative;
+  cursor: col-resize;
+}
+
+.screen-diff__container {
+  overflow-x: auto;
+}
+
+.screen-diff__image-over {
+  top: 0;
+  left: 0;
+  bottom: 0;
+  background: #fff;
+  position: absolute;
+  overflow: hidden;
+  box-shadow: 2px 0 1px -1px #aaa;
+}
+
+.screen-diff-error {
+  color: #fd5a3e;
+}

InterfaceAutoTest/report/allure/html/widgets/behaviors.json

+{
+  "total" : 3,
+  "items" : [ {
+    "uid" : "66550695002566ec8b65b624a9b94173",
+    "name" : "BPM系统-demo",
+    "statistic" : {
+      "failed" : 3,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 0,
+      "unknown" : 0,
+      "total" : 3
+    }
+  }, {
+    "uid" : "6e01d6d59ee91e3571e91df05295436f",
+    "name" : "BPM系统-老张",
+    "statistic" : {
+      "failed" : 2,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 0,
+      "unknown" : 0,
+      "total" : 2
+    }
+  }, {
+    "uid" : "94f1553abd732a71c34e7dce06118ae5",
+    "name" : "BPM-场景测试",
+    "statistic" : {
+      "failed" : 0,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 3,
+      "unknown" : 0,
+      "total" : 3
+    }
+  } ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/widgets/categories-trend.json

+[ {
+  "data" : {
+    "Product defects" : 5
+  }
+} ]
\ No newline at end of file

InterfaceAutoTest/report/allure/html/widgets/categories.json

+{
+  "total" : 1,
+  "items" : [ {
+    "uid" : "8fb3a91ba5aaf9de24cc8a92edc82b5d",
+    "name" : "Product defects",
+    "statistic" : {
+      "failed" : 5,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 0,
+      "unknown" : 0,
+      "total" : 5
+    }
+  } ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/widgets/duration-trend.json

+[ {
+  "data" : {
+    "duration" : 57069
+  }
+} ]
\ No newline at end of file

InterfaceAutoTest/report/allure/html/widgets/duration.json

+[ {
+  "uid" : "8142d41860b04b15",
+  "name" : "反向用例-密码正确,用户名过长",
+  "time" : {
+    "start" : 1716272599315,
+    "stop" : 1716272599407,
+    "duration" : 92
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "139913cc61e34bb9",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272610326,
+    "stop" : 1716272610382,
+    "duration" : 56
+  },
+  "status" : "failed",
+  "severity" : "normal"
+}, {
+  "uid" : "80142e22de024a60",
+  "name" : "正向用例-正确输入用户名和密码",
+  "time" : {
+    "start" : 1716272598748,
+    "stop" : 1716272598811,
+    "duration" : 63
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "cc6c15cf3215c8cc",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272632686,
+    "stop" : 1716272632817,
+    "duration" : 131
+  },
+  "status" : "failed",
+  "severity" : "normal"
+}, {
+  "uid" : "1bd3c031f056ab2e",
+  "name" : "反向用例-用户名正确,密码为空",
+  "time" : {
+    "start" : 1716272598829,
+    "stop" : 1716272598886,
+    "duration" : 57
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "5b0b595f880fe013",
+  "name" : "反向用例-密码正确,用户名为特殊字符",
+  "time" : {
+    "start" : 1716272599527,
+    "stop" : 1716272599627,
+    "duration" : 100
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "9a2316575f97b91e",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272621920,
+    "stop" : 1716272621978,
+    "duration" : 58
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "b6d10bbf3ce5a604",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272644883,
+    "stop" : 1716272644938,
+    "duration" : 55
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "5532c9175fb2354e",
+  "name" : "反向用例-密码正确,用户名为空",
+  "time" : {
+    "start" : 1716272599213,
+    "stop" : 1716272599306,
+    "duration" : 93
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "76ee0be7403e029e",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272644818,
+    "stop" : 1716272644873,
+    "duration" : 55
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "adb4666aed6ea6fd",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272644756,
+    "stop" : 1716272644809,
+    "duration" : 53
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "7af172a2303b627d",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272610398,
+    "stop" : 1716272610534,
+    "duration" : 136
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "f7e90e36deb68600",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272621599,
+    "stop" : 1716272621780,
+    "duration" : 181
+  },
+  "status" : "failed",
+  "severity" : "normal"
+}, {
+  "uid" : "10e8cf966692af2d",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272621795,
+    "stop" : 1716272621848,
+    "duration" : 53
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "15e35cc79ee68b8c",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272621856,
+    "stop" : 1716272621912,
+    "duration" : 56
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "ce412b2b5e44b608",
+  "name" : "登录--前置",
+  "time" : {
+    "start" : 1716272632845,
+    "stop" : 1716272632940,
+    "duration" : 95
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "510c89b87f6352b8",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272633398,
+    "stop" : 1716272633535,
+    "duration" : 137
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "6bce7862e8bf2a3f",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272655685,
+    "stop" : 1716272655817,
+    "duration" : 132
+  },
+  "status" : "failed",
+  "severity" : "normal"
+}, {
+  "uid" : "a0b87df8f50dc316",
+  "name" : "反向用例-密码正确,用户名错误",
+  "time" : {
+    "start" : 1716272599640,
+    "stop" : 1716272599737,
+    "duration" : 97
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "c26c17d72f28aa7f",
+  "name" : "反向用例-用户名正确,密码过长",
+  "time" : {
+    "start" : 1716272598895,
+    "stop" : 1716272598989,
+    "duration" : 94
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "d093b8587a3ab4f3",
+  "name" : "反向用例-用户名正确,密码为特殊字符",
+  "time" : {
+    "start" : 1716272599103,
+    "stop" : 1716272599203,
+    "duration" : 100
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "dd7fa74e2935b20a",
+  "name" : "添加维度-依赖登录",
+  "time" : {
+    "start" : 1716272632942,
+    "stop" : 1716272633094,
+    "duration" : 152
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "643ca7629b09152b",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272644557,
+    "stop" : 1716272644742,
+    "duration" : 185
+  },
+  "status" : "failed",
+  "severity" : "normal"
+}, {
+  "uid" : "e425d3e0108cef57",
+  "name" : "反向用例-用户名正确,密码过短",
+  "time" : {
+    "start" : 1716272598998,
+    "stop" : 1716272599093,
+    "duration" : 95
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "7efd9dd32f98b518",
+  "name" : "test用例函数-依赖登录成功和添加维度成功",
+  "time" : {
+    "start" : 1716272633097,
+    "stop" : 1716272633098,
+    "duration" : 1
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "96596e0fab9d3415",
+  "name" : "反向用例-密码正确,用户名过短",
+  "time" : {
+    "start" : 1716272599418,
+    "stop" : 1716272599517,
+    "duration" : 99
+  },
+  "status" : "passed",
+  "severity" : "normal"
+} ]
\ No newline at end of file

InterfaceAutoTest/report/allure/html/widgets/environment.json

+[ ]
\ No newline at end of file

InterfaceAutoTest/report/allure/html/widgets/executors.json

+[ ]
\ No newline at end of file

InterfaceAutoTest/report/allure/html/widgets/history-trend.json

+[ {
+  "data" : {
+    "failed" : 5,
+    "broken" : 0,
+    "skipped" : 0,
+    "passed" : 21,
+    "unknown" : 0,
+    "total" : 26
+  }
+} ]
\ No newline at end of file

InterfaceAutoTest/report/allure/html/widgets/launch.json

+[ ]
\ No newline at end of file

InterfaceAutoTest/report/allure/html/widgets/retry-trend.json

+[ {
+  "data" : {
+    "run" : 26,
+    "retry" : 25
+  }
+} ]
\ No newline at end of file

InterfaceAutoTest/report/allure/html/widgets/severity.json

+[ {
+  "uid" : "7efd9dd32f98b518",
+  "name" : "test用例函数-依赖登录成功和添加维度成功",
+  "time" : {
+    "start" : 1716272633097,
+    "stop" : 1716272633098,
+    "duration" : 1
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "d093b8587a3ab4f3",
+  "name" : "反向用例-用户名正确,密码为特殊字符",
+  "time" : {
+    "start" : 1716272599103,
+    "stop" : 1716272599203,
+    "duration" : 100
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "b6d10bbf3ce5a604",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272644883,
+    "stop" : 1716272644938,
+    "duration" : 55
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "6bce7862e8bf2a3f",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272655685,
+    "stop" : 1716272655817,
+    "duration" : 132
+  },
+  "status" : "failed",
+  "severity" : "normal"
+}, {
+  "uid" : "c26c17d72f28aa7f",
+  "name" : "反向用例-用户名正确,密码过长",
+  "time" : {
+    "start" : 1716272598895,
+    "stop" : 1716272598989,
+    "duration" : 94
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "f7e90e36deb68600",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272621599,
+    "stop" : 1716272621780,
+    "duration" : 181
+  },
+  "status" : "failed",
+  "severity" : "normal"
+}, {
+  "uid" : "510c89b87f6352b8",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272633398,
+    "stop" : 1716272633535,
+    "duration" : 137
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "7af172a2303b627d",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272610398,
+    "stop" : 1716272610534,
+    "duration" : 136
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "e425d3e0108cef57",
+  "name" : "反向用例-用户名正确,密码过短",
+  "time" : {
+    "start" : 1716272598998,
+    "stop" : 1716272599093,
+    "duration" : 95
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "139913cc61e34bb9",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272610326,
+    "stop" : 1716272610382,
+    "duration" : 56
+  },
+  "status" : "failed",
+  "severity" : "normal"
+}, {
+  "uid" : "15e35cc79ee68b8c",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272621856,
+    "stop" : 1716272621912,
+    "duration" : 56
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "dd7fa74e2935b20a",
+  "name" : "添加维度-依赖登录",
+  "time" : {
+    "start" : 1716272632942,
+    "stop" : 1716272633094,
+    "duration" : 152
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "96596e0fab9d3415",
+  "name" : "反向用例-密码正确,用户名过短",
+  "time" : {
+    "start" : 1716272599418,
+    "stop" : 1716272599517,
+    "duration" : 99
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "adb4666aed6ea6fd",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272644756,
+    "stop" : 1716272644809,
+    "duration" : 53
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "9a2316575f97b91e",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272621920,
+    "stop" : 1716272621978,
+    "duration" : 58
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "76ee0be7403e029e",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272644818,
+    "stop" : 1716272644873,
+    "duration" : 55
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "643ca7629b09152b",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272644557,
+    "stop" : 1716272644742,
+    "duration" : 185
+  },
+  "status" : "failed",
+  "severity" : "normal"
+}, {
+  "uid" : "1bd3c031f056ab2e",
+  "name" : "反向用例-用户名正确,密码为空",
+  "time" : {
+    "start" : 1716272598829,
+    "stop" : 1716272598886,
+    "duration" : 57
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "cc6c15cf3215c8cc",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272632686,
+    "stop" : 1716272632817,
+    "duration" : 131
+  },
+  "status" : "failed",
+  "severity" : "normal"
+}, {
+  "uid" : "ce412b2b5e44b608",
+  "name" : "登录--前置",
+  "time" : {
+    "start" : 1716272632845,
+    "stop" : 1716272632940,
+    "duration" : 95
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "a0b87df8f50dc316",
+  "name" : "反向用例-密码正确,用户名错误",
+  "time" : {
+    "start" : 1716272599640,
+    "stop" : 1716272599737,
+    "duration" : 97
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "10e8cf966692af2d",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272621795,
+    "stop" : 1716272621848,
+    "duration" : 53
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "80142e22de024a60",
+  "name" : "正向用例-正确输入用户名和密码",
+  "time" : {
+    "start" : 1716272598748,
+    "stop" : 1716272598811,
+    "duration" : 63
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "8142d41860b04b15",
+  "name" : "反向用例-密码正确,用户名过长",
+  "time" : {
+    "start" : 1716272599315,
+    "stop" : 1716272599407,
+    "duration" : 92
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "5532c9175fb2354e",
+  "name" : "反向用例-密码正确,用户名为空",
+  "time" : {
+    "start" : 1716272599213,
+    "stop" : 1716272599306,
+    "duration" : 93
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "5b0b595f880fe013",
+  "name" : "反向用例-密码正确,用户名为特殊字符",
+  "time" : {
+    "start" : 1716272599527,
+    "stop" : 1716272599627,
+    "duration" : 100
+  },
+  "status" : "passed",
+  "severity" : "normal"
+} ]
\ No newline at end of file

InterfaceAutoTest/report/allure/html/widgets/status-chart.json

+[ {
+  "uid" : "8142d41860b04b15",
+  "name" : "反向用例-密码正确,用户名过长",
+  "time" : {
+    "start" : 1716272599315,
+    "stop" : 1716272599407,
+    "duration" : 92
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "139913cc61e34bb9",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272610326,
+    "stop" : 1716272610382,
+    "duration" : 56
+  },
+  "status" : "failed",
+  "severity" : "normal"
+}, {
+  "uid" : "80142e22de024a60",
+  "name" : "正向用例-正确输入用户名和密码",
+  "time" : {
+    "start" : 1716272598748,
+    "stop" : 1716272598811,
+    "duration" : 63
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "cc6c15cf3215c8cc",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272632686,
+    "stop" : 1716272632817,
+    "duration" : 131
+  },
+  "status" : "failed",
+  "severity" : "normal"
+}, {
+  "uid" : "1bd3c031f056ab2e",
+  "name" : "反向用例-用户名正确,密码为空",
+  "time" : {
+    "start" : 1716272598829,
+    "stop" : 1716272598886,
+    "duration" : 57
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "5b0b595f880fe013",
+  "name" : "反向用例-密码正确,用户名为特殊字符",
+  "time" : {
+    "start" : 1716272599527,
+    "stop" : 1716272599627,
+    "duration" : 100
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "9a2316575f97b91e",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272621920,
+    "stop" : 1716272621978,
+    "duration" : 58
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "b6d10bbf3ce5a604",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272644883,
+    "stop" : 1716272644938,
+    "duration" : 55
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "5532c9175fb2354e",
+  "name" : "反向用例-密码正确,用户名为空",
+  "time" : {
+    "start" : 1716272599213,
+    "stop" : 1716272599306,
+    "duration" : 93
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "76ee0be7403e029e",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272644818,
+    "stop" : 1716272644873,
+    "duration" : 55
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "adb4666aed6ea6fd",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272644756,
+    "stop" : 1716272644809,
+    "duration" : 53
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "7af172a2303b627d",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272610398,
+    "stop" : 1716272610534,
+    "duration" : 136
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "f7e90e36deb68600",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272621599,
+    "stop" : 1716272621780,
+    "duration" : 181
+  },
+  "status" : "failed",
+  "severity" : "normal"
+}, {
+  "uid" : "10e8cf966692af2d",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272621795,
+    "stop" : 1716272621848,
+    "duration" : 53
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "15e35cc79ee68b8c",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272621856,
+    "stop" : 1716272621912,
+    "duration" : 56
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "ce412b2b5e44b608",
+  "name" : "登录--前置",
+  "time" : {
+    "start" : 1716272632845,
+    "stop" : 1716272632940,
+    "duration" : 95
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "510c89b87f6352b8",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272633398,
+    "stop" : 1716272633535,
+    "duration" : 137
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "6bce7862e8bf2a3f",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272655685,
+    "stop" : 1716272655817,
+    "duration" : 132
+  },
+  "status" : "failed",
+  "severity" : "normal"
+}, {
+  "uid" : "a0b87df8f50dc316",
+  "name" : "反向用例-密码正确,用户名错误",
+  "time" : {
+    "start" : 1716272599640,
+    "stop" : 1716272599737,
+    "duration" : 97
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "c26c17d72f28aa7f",
+  "name" : "反向用例-用户名正确,密码过长",
+  "time" : {
+    "start" : 1716272598895,
+    "stop" : 1716272598989,
+    "duration" : 94
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "d093b8587a3ab4f3",
+  "name" : "反向用例-用户名正确,密码为特殊字符",
+  "time" : {
+    "start" : 1716272599103,
+    "stop" : 1716272599203,
+    "duration" : 100
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "dd7fa74e2935b20a",
+  "name" : "添加维度-依赖登录",
+  "time" : {
+    "start" : 1716272632942,
+    "stop" : 1716272633094,
+    "duration" : 152
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "643ca7629b09152b",
+  "name" : "正向用例",
+  "time" : {
+    "start" : 1716272644557,
+    "stop" : 1716272644742,
+    "duration" : 185
+  },
+  "status" : "failed",
+  "severity" : "normal"
+}, {
+  "uid" : "e425d3e0108cef57",
+  "name" : "反向用例-用户名正确,密码过短",
+  "time" : {
+    "start" : 1716272598998,
+    "stop" : 1716272599093,
+    "duration" : 95
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "7efd9dd32f98b518",
+  "name" : "test用例函数-依赖登录成功和添加维度成功",
+  "time" : {
+    "start" : 1716272633097,
+    "stop" : 1716272633098,
+    "duration" : 1
+  },
+  "status" : "passed",
+  "severity" : "normal"
+}, {
+  "uid" : "96596e0fab9d3415",
+  "name" : "反向用例-密码正确,用户名过短",
+  "time" : {
+    "start" : 1716272599418,
+    "stop" : 1716272599517,
+    "duration" : 99
+  },
+  "status" : "passed",
+  "severity" : "normal"
+} ]
\ No newline at end of file

InterfaceAutoTest/report/allure/html/widgets/suites.json

+{
+  "total" : 3,
+  "items" : [ {
+    "uid" : "7a8b7e46177bbd4d1efa8551fea4a38d",
+    "name" : "test_case.test_demo",
+    "statistic" : {
+      "failed" : 3,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 14,
+      "unknown" : 0,
+      "total" : 17
+    }
+  }, {
+    "uid" : "663b5eac116b5bc6651b8e1e82719203",
+    "name" : "test_case.test_mirZhang",
+    "statistic" : {
+      "failed" : 2,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 4,
+      "unknown" : 0,
+      "total" : 6
+    }
+  }, {
+    "uid" : "5fa37ee52138cac4807b87b482b5d721",
+    "name" : "test_case.test_dependency",
+    "statistic" : {
+      "failed" : 0,
+      "broken" : 0,
+      "skipped" : 0,
+      "passed" : 3,
+      "unknown" : 0,
+      "total" : 3
+    }
+  } ]
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/html/widgets/summary.json

+{
+  "reportName" : "Allure Report",
+  "testRuns" : [ ],
+  "statistic" : {
+    "failed" : 5,
+    "broken" : 0,
+    "skipped" : 0,
+    "passed" : 21,
+    "unknown" : 0,
+    "total" : 26
+  },
+  "time" : {
+    "start" : 1716272598748,
+    "stop" : 1716272655817,
+    "duration" : 57069,
+    "minDuration" : 1,
+    "maxDuration" : 185,
+    "sumDuration" : 2426
+  }
+}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/0007dc75-94fb-4c53-a4b6-50fd9b798f04-container.json

+{"uuid": "0bf15b3d-f4ad-454c-9864-e0252ea4c961", "befores": [{"name": "case_level", "status": "passed", "start": 1716272651357, "stop": 1716272651357}], "start": 1716272651357, "stop": 1716272651502}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/00524ab0-f0f1-4aa8-afd7-10c62b64d6e0-container.json

+{"uuid": "685ee612-58df-46f3-b4f5-794a2042ea3a", "befores": [{"name": "case_level", "status": "passed", "start": 1716272632685, "stop": 1716272632685}], "start": 1716272632685, "stop": 1716272632840}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/005b585c-fc6f-464a-a91f-5849793c0684-container.json

+{"uuid": "c047281a-89b2-4a9f-9671-d94e1a630b04", "befores": [{"name": "method", "status": "passed", "start": 1716272610397, "stop": 1716272610397}], "start": 1716272610397, "stop": 1716272610536}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/00d90c7e-a382-4af7-b3bd-7685b1a06be5-container.json

+{"uuid": "37901bbe-6b86-41ac-a2eb-b0b6fccaf39b", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272633396, "stop": 1716272633397}], "start": 1716272633396, "stop": 1716272633536}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/00fa6ee6-521c-4a1a-a456-ce62d6c5329d-container.json

+{"uuid": "74957ac1-b488-44b6-ae15-f8d7296e25de", "befores": [{"name": "api_name", "status": "passed", "start": 1716272640166, "stop": 1716272640166}], "start": 1716272640166, "stop": 1716272640352}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/01c3368d-d999-49d2-81d2-fa1ec79c60fe-container.json

+{"uuid": "2f26fdbb-b6ba-45ae-aa61-fa2ff4128c02", "befores": [{"name": "module_name", "status": "passed", "start": 1716272599102, "stop": 1716272599102}], "start": 1716272599102, "stop": 1716272599208}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/01e18fd9-42f9-4bcd-974a-5d536b223172-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803532844318720"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803541883043840"}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/03685f49-eef3-4bf3-b7e0-86b1a3327c54-container.json

+{"uuid": "c08da0ca-507e-448e-9c7a-1202a490de13", "befores": [{"name": "module_name", "status": "passed", "start": 1716272637955, "stop": 1716272637955}], "start": 1716272637955, "stop": 1716272638149}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/03963f22-2b7c-4239-9f90-7a87ad0c1ceb-container.json

+{"uuid": "21b2a738-d780-4e5b-b82a-d15a302ed34a", "befores": [{"name": "module_name", "status": "passed", "start": 1716272599212, "stop": 1716272599212}], "start": 1716272599212, "stop": 1716272599312}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/03a0d15f-dfec-41d7-8c66-73632d63be03-container.json

+{"uuid": "dddd8ab5-c61e-4771-9401-58a9c328961d", "befores": [{"name": "mime", "status": "passed", "start": 1716272647081, "stop": 1716272647081}], "start": 1716272647081, "stop": 1716272647181}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/041c4c5d-8cc6-456c-8577-c11f2d2bb0e9-container.json

+{"uuid": "8cf06171-fde2-48dd-9cef-326d59e3d055", "befores": [{"name": "mime", "status": "passed", "start": 1716272626206, "stop": 1716272626206}], "start": 1716272626206, "stop": 1716272626351}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/0453ac8d-bc38-4c0b-bd86-e5bd9e1535a5-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/046b80cc-dde2-4f80-986c-b1dfe94560aa-container.json

+{"uuid": "d4e0c411-9956-42f8-918c-a683946dd5be", "befores": [{"name": "update_key", "status": "passed", "start": 1716272599527, "stop": 1716272599527}], "start": 1716272599527, "stop": 1716272599627}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/0477a441-021e-48ba-9ada-e48d3d55e9d2-container.json

+{"uuid": "6a2b4bd9-f74d-4896-9dab-23e3561fe97a", "befores": [{"name": "update_key", "status": "passed", "start": 1716272619383, "stop": 1716272619383}], "start": 1716272619383, "stop": 1716272619573}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/04d15195-6da2-42ea-8d54-c79fd8fef927-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTg5OTgsImlhdCI6MTcxNjI3MjU5OH0.4JgpWuf9sSQnYV9dPIhf0I76OkCqUlLws0abjIB0nEM_iXrT2qd79jiUvk3kiwUvDIw9aHYQdvVjAFq8AQLNCw","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDAsImlhdCI6MTcxNjI3MjYwMH0.atAGdmkk-bhC9iAhggDWp0VlgVLl39hN3_u2ytWqmjm1GWT-vhDYRgCax56GrBuR6EkPJEseXgX-S8EfzoWXhg","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/04ea3688-03fd-4742-bc5d-591b18fdd3c1-container.json

+{"uuid": "226e0fa2-2ee1-42d7-bec9-aca2cb096233", "befores": [{"name": "api_name", "status": "passed", "start": 1716272608243, "stop": 1716272608243}], "start": 1716272608243, "stop": 1716272608307}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/050f736a-4c14-4161-bff8-c02c54307aeb-attachment.txt

+断言

InterfaceAutoTest/report/allure/json/05510126-4185-4429-ade2-1f1e848033c5-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/057abcb8-6719-4f75-9ba0-21f883ad287b-container.json

+{"uuid": "96543332-39f5-42aa-b859-24cce9f5245a", "befores": [{"name": "module_name", "status": "passed", "start": 1716272642364, "stop": 1716272642364}], "start": 1716272642364, "stop": 1716272642552}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/05989502-67f1-4f92-83e4-6d5f60e577e3-container.json

+{"uuid": "c3c49881-d63a-4311-b288-4bd1560f9d01", "befores": [{"name": "case_level", "status": "passed", "start": 1716272599754, "stop": 1716272599754}], "start": 1716272599754, "stop": 1716272600009}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/05d5d3f8-02d2-4aa9-a7b0-9bb078bda7c8-container.json

+{"uuid": "e24798ef-808f-49e3-8fb0-d48a47a0aec7", "befores": [{"name": "update_key", "status": "passed", "start": 1716272644883, "stop": 1716272644883}], "start": 1716272644883, "stop": 1716272644938}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/06296877-4989-47a6-9a09-98b784ba0d71-container.json

+{"uuid": "e8f6a2b7-9e01-47e8-9775-8b44f2a4e474", "befores": [{"name": "update_key", "status": "passed", "start": 1716272612749, "stop": 1716272612749}], "start": 1716272612749, "stop": 1716272612938}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/066fc29c-43d7-4ee6-bdb0-721c8c44a187-container.json

+{"uuid": "69d01c4e-06de-4f80-88a9-3d9f0cff3f89", "befores": [{"name": "case_level", "status": "passed", "start": 1716272598997, "stop": 1716272598997}], "start": 1716272598997, "stop": 1716272599097}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/067f8831-bdae-4e74-8c1a-132ac8d25cca-container.json

+{"uuid": "d48e8221-7f31-4bc1-bfc3-a054fbb76afc", "befores": [{"name": "mime", "status": "passed", "start": 1716272617174, "stop": 1716272617174}], "start": 1716272617174, "stop": 1716272617363}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/06b7ab20-aa5d-489e-ae13-0a082a4ad043-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/0711a3c8-b33b-4062-9ece-1c7d6f77e7d0-container.json

+{"uuid": "46371412-faee-451b-86c3-90e0bb2d8ccb", "befores": [{"name": "module_name", "status": "passed", "start": 1716272598747, "stop": 1716272598747}], "start": 1716272598747, "stop": 1716272598824}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/07a873a4-c3b7-4a08-91b8-d19469c954bf-container.json

+{"uuid": "e136c064-5ff8-46cc-9c68-b26df94b1a66", "befores": [{"name": "module_name", "status": "passed", "start": 1716272598827, "stop": 1716272598828}], "start": 1716272598827, "stop": 1716272598890}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/07f91c86-85f9-461f-a359-58ad67741604-container.json

+{"uuid": "c249e50b-1675-4389-a910-e9d842d3e24f", "befores": [{"name": "api_name", "status": "passed", "start": 1716272610541, "stop": 1716272610541}], "start": 1716272610541, "stop": 1716272610736}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/0804894f-702d-4fca-9561-fdf7f142c0fb-container.json

+{"uuid": "4f16e11b-188c-4072-9e70-892f0b6f7875", "befores": [{"name": "update_key", "status": "passed", "start": 1716272640167, "stop": 1716272640167}], "start": 1716272640167, "stop": 1716272640348}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/08187e45-0cd8-4df3-b4df-d6aeeab9fd08-container.json

+{"uuid": "32880bc8-53ea-4b0b-95f2-7c7713f30b74", "befores": [{"name": "api_name", "status": "passed", "start": 1716272644958, "stop": 1716272644958}], "start": 1716272644958, "stop": 1716272645065}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/084983c7-8908-4615-89a8-7fa798555ebf-container.json

+{"uuid": "7b62ef0b-8fe4-4a0d-bc6c-cbe4b949e223", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272624098, "stop": 1716272624098}], "start": 1716272624098, "stop": 1716272624193}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/088a9831-b29f-48c6-b4b3-35e297dc94f1-container.json

+{"uuid": "da850ac7-dec9-4f1b-901b-89de8f3f7ee9", "befores": [{"name": "case_level", "status": "passed", "start": 1716272599102, "stop": 1716272599102}], "start": 1716272599102, "stop": 1716272599207}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/088c704f-73e7-4f16-bb8e-9ee911b86870-container.json

+{"uuid": "a575da8f-9b28-4a37-ab30-21c5db9e3e5b", "befores": [{"name": "mime", "status": "passed", "start": 1716272610397, "stop": 1716272610397}], "start": 1716272610397, "stop": 1716272610536}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/0a020a50-c2f2-4a3f-a703-49ce7d04bc45-container.json

+{"uuid": "4bddc20b-93f9-41d5-956b-e7fdf3d157ab", "befores": [{"name": "update_key", "status": "passed", "start": 1716272599212, "stop": 1716272599212}], "start": 1716272599212, "stop": 1716272599306}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/0a5ad3e7-1b15-468b-a1a2-85c371fa5d1f-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功", "trace": "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "18203871-00d2-484a-8825-b23713f6f03e-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'组织管理'"}, {"name": "api_name", "value": "'添加组织'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'高'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/org/v1/org/addOrg'"}, {"name": "mime", "value": "'json'"}, {"name": "case_data", "value": "{'code': 'test_add_org', 'demId': '需要更新', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}"}, {"name": "expect_data", "value": "{'message': '添加组织成功'}"}, {"name": "sql_data", "value": "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}"}, {"name": "sql_type", "value": "'select|delete'"}, {"name": "update_key", "value": "'demId'"}], "start": 1716272633544, "stop": 1716272633720, "uuid": "dc48b39d-111b-4056-9500-807350a26c70", "historyId": "526f1fd519b78b4955668d6cfd277048", "testCaseId": "8c3ca9784f7a20f46f527b41c7204e5a", "fullName": "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "组织管理"}, {"name": "story", "value": "添加组织"}, {"name": "severity", "value": "高"}, {"name": "epic", "value": "BPM系统-老张"}, {"name": "parentSuite", "value": "test_case.test_mirZhang"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_mirZhang.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/0a643507-4216-4b1b-8e97-8a9cb4953e33-container.json

+{"uuid": "511132eb-602b-4e01-8e3f-ccee474db0b7", "befores": [{"name": "case_title", "status": "passed", "start": 1716272626206, "stop": 1716272626206}], "start": 1716272626206, "stop": 1716272626352}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/0adfc910-1873-455f-b65b-a839ef93d323-container.json

+{"uuid": "2bad23d3-14b8-474c-85a4-5ce7cbf7ca44", "befores": [{"name": "case_data", "status": "passed", "start": 1716272644756, "stop": 1716272644756}], "start": 1716272644756, "stop": 1716272644811}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/0b7d418a-4501-4ed7-88e0-3da15f279ddb-container.json

+{"uuid": "37f1fe0d-4345-4f46-98c5-f6f642603aac", "befores": [{"name": "api_name", "status": "passed", "start": 1716272630525, "stop": 1716272630525}], "start": 1716272630525, "stop": 1716272630671}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/0b9917c1-669f-47dd-a3c4-00e0e6b29189-container.json

+{"uuid": "ec0a09b8-c2e3-40be-80e8-323fb60a2bc1", "befores": [{"name": "url", "status": "passed", "start": 1716272653520, "stop": 1716272653520}], "start": 1716272653520, "stop": 1716272653671}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/0b9f7723-4e8c-4044-a88c-8536acd32463-container.json

+{"uuid": "bd1258e3-de59-4ead-aaf2-47b00893216b", "befores": [{"name": "update_key", "status": "passed", "start": 1716272608243, "stop": 1716272608243}], "start": 1716272608243, "stop": 1716272608302}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/0be0f8ba-cd5d-45f6-9c86-b79a73be7457-attachment.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为test_add_org, 期望数据为:{'state': True, 'message': '删除组织成功！', 'value': ''}, 服务器返回的数据为：{"state":true,"message":"删除组织成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/0c2a0da5-b50f-4690-9618-dd995a4b2c27-container.json

+{"uuid": "c56792ee-0133-4789-8253-d1f23bf3ae73", "befores": [{"name": "case_data", "status": "passed", "start": 1716272633543, "stop": 1716272633543}], "start": 1716272633543, "stop": 1716272633730}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/0c3ea456-8814-4141-b563-c3c9b662f720-container.json

+{"uuid": "dbfc7df8-7efa-45a2-8dae-f5a5a2cbae3d", "befores": [{"name": "case_title", "status": "passed", "start": 1716272599639, "stop": 1716272599639}], "start": 1716272599639, "stop": 1716272599740}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/0c537225-5b94-4202-93ef-7d1b9a093426-container.json

+{"uuid": "81441cd6-ead2-4adc-9e9e-30e8959e0511", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272599102, "stop": 1716272599102}], "start": 1716272599102, "stop": 1716272599206}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/0c5a26e3-db88-4d6e-b01a-857990738541-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/0c9de62a-ba6e-4152-9814-fd4e9af0bfe2-container.json

+{"uuid": "ffc90896-8c4a-409c-879e-2147917405fd", "befores": [{"name": "api_name", "status": "passed", "start": 1716272637955, "stop": 1716272637955}], "start": 1716272637955, "stop": 1716272638149}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/0de453a9-dd6c-4128-a9fd-8497a9e07e32-container.json

+{"uuid": "e4151cbb-4548-415d-8725-d431cda89ac6", "befores": [{"name": "url", "status": "passed", "start": 1716272599639, "stop": 1716272599639}], "start": 1716272599639, "stop": 1716272599740}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/0e4027ad-174c-4f79-8955-840d5403e6dd-container.json

+{"uuid": "6142d282-6366-4baa-b723-27ea2da94b4a", "befores": [{"name": "mime", "status": "passed", "start": 1716272604094, "stop": 1716272604094}], "start": 1716272604094, "stop": 1716272604154}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/0e9153ef-ec39-4b60-b4cd-1023ec5b5b5f-result.json

+{"name": "反向用例-密码正确,用户名为空", "status": "passed", "attachments": [{"name": "log", "source": "4bcb6226-c1aa-4031-bbd9-a0fb2c8c397a-attachment.txt", "type": "text/plain"}, {"name": "stdout", "source": "ff1b7ef5-5c75-4e56-9781-3197149c28b8-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'认证接口'"}, {"name": "api_name", "value": "'登录系统'"}, {"name": "case_title", "value": "'反向用例-密码正确,用户名为空'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/auth'"}, {"name": "mime", "value": "'application/json'"}, {"name": "case_data", "value": "{'username': '', 'password': 'MTIzNDU2'}"}, {"name": "expect_data", "value": "{'message': '账号或密码错误'}"}, {"name": "sql_data", "value": "None"}, {"name": "sql_type", "value": "None"}, {"name": "update_key", "value": "None"}], "start": 1716272599213, "stop": 1716272599306, "uuid": "f710be2f-06ac-4f7b-9de8-4e5de112e5b7", "historyId": "ca39ba3d830745ef2c54de45a0fd94de", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "认证接口"}, {"name": "story", "value": "登录系统"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/0eb02d5e-4c23-4ad1-bb94-8d6daa55137a-container.json

+{"uuid": "2fbc64fb-f67f-4171-937d-553da4255c5a", "befores": [{"name": "case_data", "status": "passed", "start": 1716272621920, "stop": 1716272621920}], "start": 1716272621920, "stop": 1716272621980}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/0ebce774-fe09-4ee5-8e98-a2e8ccd3ac3f-container.json

+{"uuid": "02cf4629-73cf-4166-8f91-bb9a35a199f5", "befores": [{"name": "case_title", "status": "passed", "start": 1716272630525, "stop": 1716272630525}], "start": 1716272630525, "stop": 1716272630670}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/0ebcfa66-695f-4394-bd2a-ae39856c3caf-attachment.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'orgCode': 'test_add_org', 'accounts': 'admin'}, 期望数据为:{'state': True, 'message': '加入成功', 'value': ''}, 服务器返回的数据为：{"state":true,"message":"加入成功","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/0ed32c3a-71a9-464b-9d1c-89acbbf9a760-attachment.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'orgCode': 'test_add_org', 'accounts': 'admin'}, 期望数据为:{'state': True, 'message': '加入成功', 'value': ''}, 服务器返回的数据为：{"state":true,"message":"加入成功","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/0f1f35d7-4a73-4ca7-af65-2bd5b1e3248d-container.json

+{"uuid": "91f03356-92de-4a90-b4b4-ad9bd2bb9a37", "befores": [{"name": "api_name", "status": "passed", "start": 1716272621794, "stop": 1716272621794}], "start": 1716272621794, "stop": 1716272621851}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/10c02a72-3129-485c-9568-680e51e955c6-container.json

+{"uuid": "9720b981-ba89-4170-89e2-40e8b1256cef", "befores": [{"name": "case_level", "status": "passed", "start": 1716272599315, "stop": 1716272599315}], "start": 1716272599315, "stop": 1716272599412}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/10c7e8c8-881d-49ca-ba1e-9fc5f06dd9f8-container.json

+{"uuid": "b735b220-3783-4b7f-994f-aa0d2d0cf7f3", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272599315, "stop": 1716272599315}], "start": 1716272599315, "stop": 1716272599410}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/11745873-9a80-4a58-a31b-2f11541137ca-container.json

+{"uuid": "32d8b096-a51d-4f9b-890f-2225aeabe060", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272644817, "stop": 1716272644817}], "start": 1716272644817, "stop": 1716272644874}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/11b071c4-e784-4942-b4d3-36233827d2cd-container.json

+{"uuid": "1defcf87-0a92-4f53-8287-b70f13f384ce", "befores": [{"name": "update_key", "status": "passed", "start": 1716272655685, "stop": 1716272655685}], "start": 1716272655685, "stop": 1716272655825}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/11f871d8-a549-44a0-9f84-3a39df1c22f6-container.json

+{"uuid": "61460a6a-21b4-4627-aa5b-38596ce55735", "befores": [{"name": "update_key", "status": "passed", "start": 1716272621920, "stop": 1716272621920}], "start": 1716272621920, "stop": 1716272621978}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/1245f17a-0dbf-4770-a5b1-dcaf27c9e1dc-container.json

+{"uuid": "78efe232-dc59-40dd-a7a4-0c326a89c13c", "befores": [{"name": "method", "status": "passed", "start": 1716272619383, "stop": 1716272619383}], "start": 1716272619383, "stop": 1716272619577}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/125d8349-e88c-4bef-bf80-a65cdc879fbc-container.json

+{"uuid": "806d3174-b17b-405b-b3e3-2c48f50d0420", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272608243, "stop": 1716272608243}], "start": 1716272608243, "stop": 1716272608303}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/1324fec5-31a7-4ab4-9ba0-7a3d33cbffb0-container.json

+{"uuid": "d805b7bf-09ea-4959-a185-e62b52022508", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272617174, "stop": 1716272617174}], "start": 1716272617174, "stop": 1716272617362}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/13351147-ec9a-4e14-9536-866b25a993f7-container.json

+{"uuid": "7395258f-5158-4def-b518-cf2cac74af73", "befores": [{"name": "update_key", "status": "passed", "start": 1716272644817, "stop": 1716272644817}], "start": 1716272644817, "stop": 1716272644873}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/14689d85-9a3b-4e3b-bfa1-df833a8838ae-container.json

+{"uuid": "0abf3798-b631-404d-b8ab-245edb4ce2f3", "befores": [{"name": "case_title", "status": "passed", "start": 1716272598828, "stop": 1716272598828}], "start": 1716272598828, "stop": 1716272598889}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/149444b8-ff06-46a9-998a-56bf5708825d-container.json

+{"uuid": "047dd5fa-4e36-4c55-b77f-d969da2032e9", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272640167, "stop": 1716272640167}], "start": 1716272640167, "stop": 1716272640349}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/14a88771-583d-44f3-aff2-1cddacf52485-container.json

+{"uuid": "2145dfcd-bc1e-44eb-9489-e8ebc6610eaf", "befores": [{"name": "update_key", "status": "passed", "start": 1716272598748, "stop": 1716272598748}], "start": 1716272598748, "stop": 1716272598811}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/14f44cbb-09dd-4c81-98b3-421897721281-container.json

+{"uuid": "692f4ef3-26cf-4dd8-ac29-210ee8bde137", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272644557, "stop": 1716272644557}], "start": 1716272644557, "stop": 1716272644749}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/15729cac-12f7-460d-b86a-6c88d6448ec5-container.json

+{"uuid": "50332d9a-d46d-4d71-b2bc-5cc7a19d8b01", "befores": [{"name": "api_name", "status": "passed", "start": 1716272633543, "stop": 1716272633543}], "start": 1716272633543, "stop": 1716272633732}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/15ebbd96-5ae7-4210-8d7b-2d363a5cf62b-container.json

+{"uuid": "2bd51c4f-835d-42e4-bf40-642646eebaf9", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272644756, "stop": 1716272644756}], "start": 1716272644756, "stop": 1716272644810}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/160eef0a-9c3b-45a1-84a3-4561d7ff8958-container.json

+{"uuid": "e5ac9538-10cc-43ee-96a6-8d1a8f3edb64", "befores": [{"name": "case_level", "status": "passed", "start": 1716272606163, "stop": 1716272606163}], "start": 1716272606163, "stop": 1716272606226}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/172c723d-76f9-4356-b4ab-c668e22b15c6-container.json

+{"uuid": "06a7d040-4fe6-48b9-89a5-e526ff632e81", "befores": [{"name": "case_level", "status": "passed", "start": 1716272604094, "stop": 1716272604094}], "start": 1716272604094, "stop": 1716272604155}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/1736be70-4772-4a84-aaa3-df20ef6a1132-container.json

+{"uuid": "0a431f21-d676-46b7-ab3c-a4c650c58545", "befores": [{"name": "case_title", "status": "passed", "start": 1716272599314, "stop": 1716272599315}], "start": 1716272599314, "stop": 1716272599412}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/17618a73-c667-4508-8824-4c6bf152ac1c-container.json

+{"uuid": "d716d82b-b7f7-4373-b05d-e09caf8b16e5", "befores": [{"name": "method", "status": "passed", "start": 1716272599754, "stop": 1716272599754}], "start": 1716272599754, "stop": 1716272600009}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/1775f311-bf31-4c70-8913-c50e752e39e3-container.json

+{"uuid": "03e4d1bb-62f5-4e3b-bd18-add6a164fbd2", "befores": [{"name": "method", "status": "passed", "start": 1716272602023, "stop": 1716272602023}], "start": 1716272602023, "stop": 1716272602083}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/17b5125b-50d2-4548-8014-f36bb2389733-container.json

+{"uuid": "4e6fea3b-f57d-47da-9615-3a82a65ed7f9", "befores": [{"name": "module_name", "status": "passed", "start": 1716272653520, "stop": 1716272653520}], "start": 1716272653520, "stop": 1716272653674}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/17cc681b-f021-4cd0-8cb6-e1b41a971068-container.json

+{"uuid": "b6f27304-52e7-49dd-be86-e3ffa393b6fc", "befores": [{"name": "mime", "status": "passed", "start": 1716272630525, "stop": 1716272630525}], "start": 1716272630525, "stop": 1716272630669}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/17cd4d06-16ca-402a-a721-90dd040c04c8-container.json

+{"uuid": "4fb0731a-8835-49ee-83a4-a5abed5a1b3c", "befores": [{"name": "case_level", "status": "passed", "start": 1716272621855, "stop": 1716272621855}], "start": 1716272621855, "stop": 1716272621916}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/18203871-00d2-484a-8825-b23713f6f03e-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/18562841-5a08-47cc-bb50-864ab4887488-container.json

+{"uuid": "07111704-3daa-49b0-931c-0bfc1c2e3d05", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272614968, "stop": 1716272614968}], "start": 1716272614968, "stop": 1716272615155}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/18cdad33-1004-49c1-ab8c-bc6147e1ea01-container.json

+{"uuid": "c9af3f8d-4140-41d0-81a9-aa65b1a348be", "befores": [{"name": "update_key", "status": "passed", "start": 1716272610325, "stop": 1716272610325}], "start": 1716272610325, "stop": 1716272610390}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/18f4d9d6-5b7f-4bc3-90af-2ae04f401690-container.json

+{"uuid": "9b0e3c6c-7e5f-42bf-96bc-67e7e68d8669", "befores": [{"name": "case_title", "status": "passed", "start": 1716272644756, "stop": 1716272644756}], "start": 1716272644756, "stop": 1716272644812}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/19449c40-8f6f-4761-afa6-88630a60b273-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '刷新token成功' == None\n +  where None = <built-in method get of dict object at 0x0000014F191C40C0>('message')\n +    where <built-in method get of dict object at 0x0000014F191C40C0> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwOH0.LsIqI6NBfMYmLfeFQHaiE3TLchmrNO9P3P92GkiuQQoiDTEXfelTGerbpaF-Qp4K4_45jG2cACLNB8dNwS0m-w', 'userAttrs': {}, ...}.get\n +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwOH0.LsIqI6NBfMYmLfeFQHaiE3TLchmrNO9P3P92GkiuQQoiDTEXfelTGerbpaF-Qp4K4_45jG2cACLNB8dNwS0m-w', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\n +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json", "trace": "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '刷新token成功' == None\nE                +  where None = <built-in method get of dict object at 0x0000014F191C40C0>('message')\nE                +    where <built-in method get of dict object at 0x0000014F191C40C0> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwOH0.LsIqI6NBfMYmLfeFQHaiE3TLchmrNO9P3P92GkiuQQoiDTEXfelTGerbpaF-Qp4K4_45jG2cACLNB8dNwS0m-w', 'userAttrs': {}, ...}.get\nE                +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwOH0.LsIqI6NBfMYmLfeFQHaiE3TLchmrNO9P3P92GkiuQQoiDTEXfelTGerbpaF-Qp4K4_45jG2cACLNB8dNwS0m-w', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\nE                +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "abf84792-f2ec-441a-a2b2-2d91eac46968-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'认证接口'"}, {"name": "api_name", "value": "'刷新token'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'GET'"}, {"name": "url", "value": "'http://120.46.172.186:8080/refresh'"}, {"name": "mime", "value": "None"}, {"name": "case_data", "value": "None"}, {"name": "expect_data", "value": "{'message': '刷新token成功'}"}, {"name": "sql_data", "value": "None"}, {"name": "sql_type", "value": "None"}, {"name": "update_key", "value": "None"}], "start": 1716272610326, "stop": 1716272610382, "uuid": "fd70df5f-0b98-4362-bc4d-e73ff8bff407", "historyId": "1dcae5f805bddffd6ce19e14c8b3458b", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "认证接口"}, {"name": "story", "value": "刷新token"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/19d45349-022d-460f-9551-744c7a0c4236-container.json

+{"uuid": "1e686db6-9bc7-4c17-a6e3-d57c9fde3231", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272632685, "stop": 1716272632685}], "start": 1716272632685, "stop": 1716272632829}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/1a5a808f-02c9-421a-8759-a657843dcdd6-attachment.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'code': 'api_auto_test_add_dem', 'description': 'api_auto_test_add_dem', 'isDefault': 0, 'name': 'api_auto_test_add_dem'}, 期望数据为:{'message': '添加维度成功！'}, 服务器返回的数据为：{"state":true,"message":"添加维度成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/1ac7c213-e213-455f-b270-4404fa7d6875-container.json

+{"uuid": "38e5fd55-c430-4a23-b30b-f7d81e3b3774", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272651357, "stop": 1716272651357}], "start": 1716272651357, "stop": 1716272651499}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/1c248e97-1baa-450b-806e-e84b0fa7ab59-container.json

+{"uuid": "651494ab-7d6b-4009-9a53-08303f0ccc17", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272651357, "stop": 1716272651357}], "start": 1716272651357, "stop": 1716272651500}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/1c641071-d8b1-4df1-87d7-8ac3fad1dbd6-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTg5OTgsImlhdCI6MTcxNjI3MjU5OH0.4JgpWuf9sSQnYV9dPIhf0I76OkCqUlLws0abjIB0nEM_iXrT2qd79jiUvk3kiwUvDIw9aHYQdvVjAFq8AQLNCw","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDAsImlhdCI6MTcxNjI3MjYwMH0.atAGdmkk-bhC9iAhggDWp0VlgVLl39hN3_u2ytWqmjm1GWT-vhDYRgCax56GrBuR6EkPJEseXgX-S8EfzoWXhg","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDIsImlhdCI6MTcxNjI3MjYwMn0.2ULfoTRcxys6pnuEKjHxZH4GI20D2qBisJFYoBn2GdZLw23Xapl1u2ATzI1w5cFlBcJf3_bFyVN7eo7OfOOMUg","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDQsImlhdCI6MTcxNjI3MjYwNH0.TOXPdeAD96XQ_Maa-ITQDDQZTnKhlW09esTDC6-C8_Wux9HSk3bWURoOvhmcidK-lCj4Tvw1ZO0dYFWGR8-lsg","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDYsImlhdCI6MTcxNjI3MjYwNn0.W_ynWuu-79lzZS5ScuftmKzI8_B3z3llQ0gnSpahTsvIdUBKeaos4loXKk4DrzU4CGbchLTa5lK48yzcFXXQoA","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/1d1a91b9-37d7-49e6-a8a7-e9f32fcd48e0-container.json

+{"uuid": "d6a4ec55-bfa6-4553-ac67-8ed32d82284c", "befores": [{"name": "api_name", "status": "passed", "start": 1716272599212, "stop": 1716272599212}], "start": 1716272599212, "stop": 1716272599311}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/1d1d904d-3d51-4025-9638-9f72f43bfa31-container.json

+{"uuid": "02e49788-c50d-45ff-8b58-f37b8d514bd9", "befores": [{"name": "module_name", "status": "passed", "start": 1716272649195, "stop": 1716272649196}], "start": 1716272649195, "stop": 1716272649340}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/1dce8bbd-f8cb-44ac-8c75-7d32796f3ad8-container.json

+{"uuid": "df2ae797-e025-4bbd-b55c-65612db9cc86", "befores": [{"name": "mime", "status": "passed", "start": 1716272598997, "stop": 1716272598997}], "start": 1716272598997, "stop": 1716272599095}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/1e49a6bf-90fd-4ecf-b50a-87de70b38044-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功", "trace": "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "edb607af-88bd-4b64-8430-591655c94b18-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'组织管理'"}, {"name": "api_name", "value": "'添加组织'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'高'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/org/v1/org/addOrg'"}, {"name": "mime", "value": "'json'"}, {"name": "case_data", "value": "{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}"}, {"name": "expect_data", "value": "{'message': '添加组织成功'}"}, {"name": "sql_data", "value": "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}"}, {"name": "sql_type", "value": "'select|delete'"}, {"name": "update_key", "value": "'demId'"}], "start": 1716272619383, "stop": 1716272619564, "uuid": "4eabc962-48e4-4ab7-96fe-86e283352683", "historyId": "487ae598a2b30a5ea2489bb3e5fa08a4", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "组织管理"}, {"name": "story", "value": "添加组织"}, {"name": "severity", "value": "高"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/1ef3cba0-1fd9-4ecb-ad02-74235915af9a-container.json

+{"uuid": "43d0d50f-6b48-44dd-95ce-8c64c8ec6892", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272608243, "stop": 1716272608243}], "start": 1716272608243, "stop": 1716272608303}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/1f9d619e-1671-4df0-a212-2d92ba1928d1-container.json

+{"uuid": "83b6c36e-48e4-4007-89ce-f655c2f43a46", "befores": [{"name": "method", "status": "passed", "start": 1716272626206, "stop": 1716272626206}], "start": 1716272626206, "stop": 1716272626351}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/1fca33ec-851d-4df3-892e-a38682e027a3-container.json

+{"uuid": "aeb1deb0-fb7e-4ca1-9cb5-3d8ce63f10e6", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272644883, "stop": 1716272644883}], "start": 1716272644883, "stop": 1716272644949}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/1fd5bd89-eb81-46cb-b1c1-f80049e8214e-result.json

+{"name": "登录--前置", "status": "passed", "attachments": [{"name": "stdout", "source": "d0f3b779-e73a-48a3-a0ef-788faec5fd6d-attachment.txt", "type": "text/plain"}], "start": 1716272632845, "stop": 1716272632940, "uuid": "758954b0-7299-4d44-a8e8-14d4f046ae08", "historyId": "b3ea99bce5fbf89dc61e67ffc74d2796", "testCaseId": "b3ea99bce5fbf89dc61e67ffc74d2796", "fullName": "test_case.test_dependency.test_dependency#test_login", "labels": [{"name": "feature", "value": "认证接口"}, {"name": "story", "value": "登录系统"}, {"name": "epic", "value": "BPM-场景测试"}, {"name": "tag", "value": "dependency"}, {"name": "parentSuite", "value": "test_case.test_dependency"}, {"name": "suite", "value": "test_dependency"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_dependency.test_dependency"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/20426e1a-a648-4dad-a20f-21f37d044258-container.json

+{"uuid": "0c14fc95-352c-4cda-9ae1-c3dfaf8f1f48", "befores": [{"name": "method", "status": "passed", "start": 1716272614966, "stop": 1716272614966}], "start": 1716272614966, "stop": 1716272615156}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/207026aa-9909-4cbf-98c9-22cc531445cc-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803436442435584"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803445468577792"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803454528274432"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803463587971072"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803472635084800"}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/2071e4ab-ae42-4ac8-b198-c263194085a2-container.json

+{"uuid": "928d2948-188c-4ff1-9a87-c4476d59c300", "befores": [{"name": "method", "status": "passed", "start": 1716272598747, "stop": 1716272598747}], "start": 1716272598747, "stop": 1716272598823}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/20a7ca74-dac6-427f-927a-318a2e2246d3-container.json

+{"uuid": "deeb0243-abfb-427c-992a-957dd0683068", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272606163, "stop": 1716272606163}], "start": 1716272606163, "stop": 1716272606224}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/2108c7c3-195f-41fc-b2e8-7ac18b82fd6c-container.json

+{"uuid": "78956eff-10d0-464b-a6de-273e52e9d820", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272621920, "stop": 1716272621920}], "start": 1716272621920, "stop": 1716272621980}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/210b12cf-948c-46d4-821a-7932288435ae-attachment.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'username': 'admin123', 'password': 'MTIzNDU2'}, 期望数据为:{'message': '账号或密码错误'}, 服务器返回的数据为：{"state":false,"message":"账号或密码错误","logId":"1792803333887508480"}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/21448faf-a0f5-4f10-88c4-abbcfb93a18a-container.json

+{"uuid": "6a9e38d2-fb2c-49fe-ae0e-ef9f81bc8ba5", "befores": [{"name": "case_level", "status": "passed", "start": 1716272621920, "stop": 1716272621920}], "start": 1716272621920, "stop": 1716272621983}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/21d91af9-0629-4b2b-93b8-7052dacdc6d0-container.json

+{"uuid": "494d4667-ab0f-4191-9475-dbadbbdcee0b", "befores": [{"name": "case_level", "status": "passed", "start": 1716272608243, "stop": 1716272608243}], "start": 1716272608243, "stop": 1716272608305}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/21f1fcbc-52f2-47a5-9a8e-8dde38f637ec-container.json

+{"uuid": "348e18fe-b5d2-470c-adb8-d5692c205707", "befores": [{"name": "mime", "status": "passed", "start": 1716272598893, "stop": 1716272598893}], "start": 1716272598893, "stop": 1716272598991}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/2233a8cf-8253-4568-ba89-d51a0f1e97b8-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功", "trace": "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "7913ad36-b9cd-4366-80a1-12524ce769be-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'维度管理'"}, {"name": "api_name", "value": "'根据维度编码删除维度'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'DELETE'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'"}, {"name": "mime", "value": "'query'"}, {"name": "case_data", "value": "{'ids': '1792803379156631552'}"}, {"name": "expect_data", "value": "{'message': '删除维度成功'}"}, {"name": "sql_data", "value": "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"}, {"name": "sql_type", "value": "'select'"}, {"name": "update_key", "value": "'ids'"}], "start": 1716272630526, "stop": 1716272630660, "uuid": "4e3d7a99-f37b-41d9-b955-4f01dbd839f8", "historyId": "347d2f73ed73495ba7ba72dbf723f253", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "维度管理"}, {"name": "story", "value": "根据维度编码删除维度"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/2373967f-7688-4003-96ac-4d9518e07584-container.json

+{"uuid": "d79834ec-17a8-4b74-aecb-5e2256224b3b", "befores": [{"name": "url", "status": "passed", "start": 1716272621599, "stop": 1716272621599}], "start": 1716272621599, "stop": 1716272621789}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/23a7dc2f-79fd-408f-8959-40f75859efa0-container.json

+{"uuid": "6591e899-8f87-45c7-9035-b1a15cf180a0", "befores": [{"name": "method", "status": "passed", "start": 1716272599527, "stop": 1716272599527}], "start": 1716272599527, "stop": 1716272599632}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/23c1fc84-4b46-4cec-a0e6-c1c618347715-container.json

+{"uuid": "a3672f34-511a-4e39-b8ec-217574ea5ccb", "befores": [{"name": "module_name", "status": "passed", "start": 1716272621855, "stop": 1716272621855}], "start": 1716272621855, "stop": 1716272621917}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/23c5aa71-f941-4000-a91b-41b454df9361-container.json

+{"uuid": "2d4fbde6-7508-4697-bbd8-518b8a668399", "befores": [{"name": "case_title", "status": "passed", "start": 1716272599527, "stop": 1716272599527}], "start": 1716272599527, "stop": 1716272599633}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/240cae2f-dc22-4157-9cd5-ea86a61f3b1b-container.json

+{"uuid": "6ff50d3d-afc3-4edf-b569-29241b481b8f", "befores": [{"name": "mime", "status": "passed", "start": 1716272633396, "stop": 1716272633396}], "start": 1716272633396, "stop": 1716272633538}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/24d1f4ec-1eb4-416b-93b9-8abba86bb665-container.json

+{"uuid": "0bd87547-0eb6-4325-a8b1-bef6cabfacd4", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272599212, "stop": 1716272599212}], "start": 1716272599212, "stop": 1716272599309}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/24fcc4d7-da92-4f45-b360-1a739eb9d154-container.json

+{"uuid": "449f8a8c-12b3-49e0-a53a-37b58adae944", "befores": [{"name": "mime", "status": "passed", "start": 1716272644756, "stop": 1716272644756}], "start": 1716272644756, "stop": 1716272644811}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/250d4c4a-5c63-41bb-8d3b-85de0a133942-container.json

+{"uuid": "057f1f46-b6ec-47d1-9bc9-f75dc4d1fb8d", "befores": [{"name": "update_key", "status": "passed", "start": 1716272633543, "stop": 1716272633543}], "start": 1716272633543, "stop": 1716272633728}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/257629e4-be4a-41be-95bf-86c13e452416-container.json

+{"uuid": "401c7238-6c1a-43f1-bb8f-86171d961024", "befores": [{"name": "url", "status": "passed", "start": 1716272637955, "stop": 1716272637955}], "start": 1716272637955, "stop": 1716272638147}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/258fbb84-ecc6-4c83-af56-cc410ef95802-container.json

+{"uuid": "c4f50723-dd3b-4063-b918-fa95d064e25c", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272655685, "stop": 1716272655685}], "start": 1716272655685, "stop": 1716272655835}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/26060cd5-287d-410f-ab2e-8814868b5d88-attachment.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'username': 'admin', 'password': '☯㍿卍卐'}, 期望数据为:{'message': '账号或密码错误'}, 服务器返回的数据为：{"state":false,"message":"账号或密码错误","logId":"1792803331643555840"}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/26845e7a-1b5f-415f-b1e8-f31d585101a2-result.json

+{"name": "正向用例", "status": "passed", "attachments": [{"name": "log", "source": "ae159987-41f0-4a11-8956-233831fcf803-attachment.txt", "type": "text/plain"}, {"name": "stdout", "source": "ffdc0bff-bded-4602-93d4-6abd42d0eda1-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'组织管理'"}, {"name": "api_name", "value": "'保存组织参数'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'post'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/org/v1/orgParam/saveOrgParams'"}, {"name": "mime", "value": "'query|json'"}, {"name": "case_data", "value": "{'query': {'orgCode': 'test_add_org'}, 'body': [{'alias': 'sz', 'value': 100}, {'alias': 'kc', 'value': '语文课'}]}"}, {"name": "expect_data", "value": "{'state': True, 'message': '保存组织参数成功！', 'value': ''}"}, {"name": "sql_data", "value": "None"}, {"name": "sql_type", "value": "None"}, {"name": "update_key", "value": "None"}], "start": 1716272621856, "stop": 1716272621912, "uuid": "843ddd4c-84f3-4889-af3a-e343c0cf7c83", "historyId": "e133082949e07d38e4a8587843153535", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "组织管理"}, {"name": "story", "value": "保存组织参数"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/26868743-01d1-4a97-bff2-4eb2f4c121b7-container.json

+{"uuid": "abb0fb64-16fa-4c28-9c95-51dfb05adbe3", "befores": [{"name": "url", "status": "passed", "start": 1716272633543, "stop": 1716272633543}], "start": 1716272633543, "stop": 1716272633730}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/26e7ed8f-8a0c-472f-8a9a-c12b447e23a7-container.json

+{"uuid": "075604ab-fd87-4b74-b1ba-afc7166276cd", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272604094, "stop": 1716272604095}], "start": 1716272604094, "stop": 1716272604154}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/270697f6-0292-4bff-95fc-8756213876bd-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/273500a6-484e-4a2e-9548-0b160e87b577-container.json

+{"uuid": "21fa9c6e-d29c-4553-bf46-d067d06e4b2c", "befores": [{"name": "url", "status": "passed", "start": 1716272598893, "stop": 1716272598893}], "start": 1716272598893, "stop": 1716272598992}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/273940bb-2e7e-4828-a05d-5b6d0f49f904-container.json

+{"uuid": "19cdbc52-c790-429e-b99d-dfba44a0a83b", "befores": [{"name": "case_level", "status": "passed", "start": 1716272642364, "stop": 1716272642364}], "start": 1716272642364, "stop": 1716272642551}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/2740cd9c-ff5e-496d-975a-88ea294730f6-container.json

+{"uuid": "b13bd107-33d1-474a-93c2-663ceb03b98f", "befores": [{"name": "url", "status": "passed", "start": 1716272619383, "stop": 1716272619383}], "start": 1716272619383, "stop": 1716272619576}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/274ee690-a8b5-491d-b4ee-5cec144b3120-container.json

+{"uuid": "006385f0-2b6c-46fe-95ef-adf15f5ec026", "befores": [{"name": "case_title", "status": "passed", "start": 1716272633396, "stop": 1716272633396}], "start": 1716272633396, "stop": 1716272633540}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/279ff813-11b5-44c6-9c35-902269b1ad5c-container.json

+{"uuid": "d5849693-5e10-443b-b24f-0f220be401c9", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272637956, "stop": 1716272637956}], "start": 1716272637956, "stop": 1716272638146}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/27cc4204-7b32-446e-90ed-fe52dc790de1-container.json

+{"uuid": "f57bca08-c7fd-40e4-96b7-2829643f9252", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272635751, "stop": 1716272635751}], "start": 1716272635751, "stop": 1716272635937}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/288f506b-4abc-4594-9429-51db22558d6f-container.json

+{"uuid": "dabff3ab-acbc-465c-a6d3-736e927051c1", "befores": [{"name": "module_name", "status": "passed", "start": 1716272633543, "stop": 1716272633543}], "start": 1716272633543, "stop": 1716272633732}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/28e0bb7c-b0b9-44a6-af32-3cf079adf274-container.json

+{"uuid": "22900768-e273-4013-b17c-9226272238c4", "befores": [{"name": "case_data", "status": "passed", "start": 1716272642365, "stop": 1716272642365}], "start": 1716272642365, "stop": 1716272642550}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/2a5d95b5-4dbc-46c7-8da2-7d35b2e54e3b-container.json

+{"uuid": "f501e5e8-d869-4583-95db-e345225c5d5b", "befores": [{"name": "url", "status": "passed", "start": 1716272647081, "stop": 1716272647081}], "start": 1716272647081, "stop": 1716272647182}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/2ab424b6-1de1-4885-9d59-2f53c9ebc81f-container.json

+{"uuid": "895051e0-ed51-4c18-aa0e-2e20bb7317d7", "befores": [{"name": "case_level", "status": "passed", "start": 1716272599639, "stop": 1716272599639}], "start": 1716272599639, "stop": 1716272599740}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/2aec467d-bd6f-4438-98f3-3c8b054f93ac-container.json

+{"uuid": "7d2f6bee-f4db-4aa1-adc3-889ac918542a", "befores": [{"name": "method", "status": "passed", "start": 1716272599212, "stop": 1716272599212}], "start": 1716272599212, "stop": 1716272599310}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/2c0fc9cf-10c1-4e95-a228-c396e976c380-container.json

+{"uuid": "5c1b07dd-35f5-4f92-be04-4e2777a7d267", "befores": [{"name": "method", "status": "passed", "start": 1716272599639, "stop": 1716272599639}], "start": 1716272599639, "stop": 1716272599740}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/2dcd2259-ba0e-43f0-854b-966b0266d23a-container.json

+{"uuid": "55fb07cb-04c6-4725-bc3f-02b1d9000b56", "befores": [{"name": "module_name", "status": "passed", "start": 1716272655684, "stop": 1716272655684}], "start": 1716272655684, "stop": 1716272655838}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/2dd6eef0-b36d-4780-9b84-86ebabbdf973-result.json

+{"name": "正向用例", "status": "passed", "attachments": [{"name": "log", "source": "0ebcfa66-695f-4394-bd2a-ae39856c3caf-attachment.txt", "type": "text/plain"}, {"name": "stdout", "source": "b1dcb8af-0503-40fc-addc-95dbd31061fc-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'组织管理'"}, {"name": "api_name", "value": "'组织加入用户'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'高'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/org/v1/orgUsers/addUsersForOrg'"}, {"name": "mime", "value": "'query'"}, {"name": "case_data", "value": "{'orgCode': 'test_add_org', 'accounts': 'admin'}"}, {"name": "expect_data", "value": "{'state': True, 'message': '加入成功', 'value': ''}"}, {"name": "sql_data", "value": "None"}, {"name": "sql_type", "value": "None"}, {"name": "update_key", "value": "None"}], "start": 1716272644756, "stop": 1716272644809, "uuid": "6a08f138-3af3-4851-8b40-0b3a2ace8c44", "historyId": "2d767e403ea75ccb1f14fcd976c25353", "testCaseId": "8c3ca9784f7a20f46f527b41c7204e5a", "fullName": "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "组织管理"}, {"name": "story", "value": "组织加入用户"}, {"name": "severity", "value": "高"}, {"name": "epic", "value": "BPM系统-老张"}, {"name": "parentSuite", "value": "test_case.test_mirZhang"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_mirZhang.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/2e26cfb1-998f-43c4-bcb1-8d4d8ba7217b-container.json

+{"uuid": "585a3495-5f5b-47a2-b2ec-4fd1ff24eeac", "befores": [{"name": "case_level", "status": "passed", "start": 1716272614966, "stop": 1716272614966}], "start": 1716272614966, "stop": 1716272615157}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/2ed3bd97-9bc7-432e-9799-610025592689-container.json

+{"uuid": "c1a5732b-2a1b-4d53-8215-b82e35149580", "befores": [{"name": "url", "status": "passed", "start": 1716272644882, "stop": 1716272644882}], "start": 1716272644882, "stop": 1716272644951}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/2ffa6a10-b4a8-4a3c-b67b-5fc86aca4157-container.json

+{"uuid": "5bae39ac-7529-433f-ac5f-f0c8dcfaa84c", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272642365, "stop": 1716272642365}], "start": 1716272642365, "stop": 1716272642549}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/3023d218-ab77-431e-b0dd-4d366f3d30ed-container.json

+{"uuid": "3074bea0-24de-41e0-8d37-32652fdcd29a", "befores": [{"name": "method", "status": "passed", "start": 1716272633396, "stop": 1716272633396}], "start": 1716272633396, "stop": 1716272633538}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/303a4037-fbde-462c-b65d-c8fb1a8e90e8-container.json

+{"uuid": "0ed9b467-d95b-4f13-a694-cb7042121599", "befores": [{"name": "case_title", "status": "passed", "start": 1716272632685, "stop": 1716272632685}], "start": 1716272632685, "stop": 1716272632840}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/304f676f-d393-4340-b051-72f1de71f08d-container.json

+{"uuid": "7b0d6025-d774-4870-a016-e026bf170a96", "befores": [{"name": "case_data", "status": "passed", "start": 1716272614966, "stop": 1716272614966}], "start": 1716272614966, "stop": 1716272615155}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/30644989-5621-4560-aa28-6e80eb68bc49-attachment.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'username': 'admin', 'password': ''}, 期望数据为:{'message': '账号或密码错误'}, 服务器返回的数据为：{"state":false,"message":"账号或密码错误","logId":"1792803330313961472"}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/3131e7e3-c2df-4b9e-8093-2a805a4e14bc-container.json

+{"uuid": "1c4cfc78-c4b4-43fe-b177-0268d61c29cd", "befores": [{"name": "module_name", "status": "passed", "start": 1716272606163, "stop": 1716272606163}], "start": 1716272606163, "stop": 1716272606227}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/32307c09-b496-435f-bba5-c2798db7be07-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803436442435584"}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/323193ae-2108-40a8-a1a7-c0e24d9e397e-container.json

+{"uuid": "ca22649b-d7bf-4720-8396-81a9dee2e2d2", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272602023, "stop": 1716272602023}], "start": 1716272602023, "stop": 1716272602082}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/335bcfa5-d0f5-4246-8b3c-66d106ceaa3f-container.json

+{"uuid": "27a0e0f5-cc36-4afe-ac28-b62bd58593c4", "befores": [{"name": "api_name", "status": "passed", "start": 1716272655684, "stop": 1716272655684}], "start": 1716272655684, "stop": 1716272655838}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/33b87a2b-96ad-4292-b287-665af35712b5-container.json

+{"uuid": "c8f9f680-2ba7-4798-96d0-a944d9b03ca0", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272599639, "stop": 1716272599639}], "start": 1716272599639, "stop": 1716272599739}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/33e236d7-dce1-49a2-bf11-adaa7fce4d40-container.json

+{"uuid": "382bfaa6-8652-45f5-bceb-e02cbeea2bb8", "befores": [{"name": "case_title", "status": "passed", "start": 1716272608243, "stop": 1716272608243}], "start": 1716272608243, "stop": 1716272608305}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/3417125a-7397-4bb8-83a0-106d6b1ff45b-container.json

+{"uuid": "e12fc571-6162-4934-ae1c-b223c706458f", "befores": [{"name": "case_data", "status": "passed", "start": 1716272632685, "stop": 1716272632685}], "start": 1716272632685, "stop": 1716272632838}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/34231e69-db06-4b1c-a5ba-3cfd7764b958-container.json

+{"uuid": "003e348a-795e-492f-9f89-8af413e7e93e", "befores": [{"name": "case_title", "status": "passed", "start": 1716272610397, "stop": 1716272610397}], "start": 1716272610397, "stop": 1716272610538}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/359a067e-7d82-46ad-a9aa-3c2893891209-container.json

+{"uuid": "66995f5b-ff0b-4e95-aaa6-ef7b38141ebd", "befores": [{"name": "case_level", "status": "passed", "start": 1716272640166, "stop": 1716272640166}], "start": 1716272640166, "stop": 1716272640351}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/35def739-bef4-44e2-a89a-6fe5fdfc41a1-container.json

+{"uuid": "32ccc90c-766b-4f70-b270-349f40a2e00c", "befores": [{"name": "case_level", "status": "passed", "start": 1716272621986, "stop": 1716272621986}], "start": 1716272621986, "stop": 1716272622090}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/35f80ed6-ad73-41c0-a9d3-8a0012b66a7f-result.json

+{"name": "正向用例", "status": "passed", "attachments": [{"name": "log", "source": "bc3acc63-8a54-424f-81a9-90333648739d-attachment.txt", "type": "text/plain"}, {"name": "stdout", "source": "fcf0e269-4266-4588-b63b-82148ec22cd8-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'组织管理'"}, {"name": "api_name", "value": "'保存组织参数'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'post'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/org/v1/orgParam/saveOrgParams'"}, {"name": "mime", "value": "'query|json'"}, {"name": "case_data", "value": "{'query': {'orgCode': 'test_add_org'}, 'body': [{'alias': 'sz', 'value': 100}, {'alias': 'kc', 'value': '语文课'}]}"}, {"name": "expect_data", "value": "{'state': True, 'message': '保存组织参数成功！', 'value': ''}"}, {"name": "sql_data", "value": "None"}, {"name": "sql_type", "value": "None"}, {"name": "update_key", "value": "None"}], "start": 1716272644818, "stop": 1716272644873, "uuid": "1a247420-9d19-4e3a-8d64-cfd40d37c623", "historyId": "f523c6add46569d79b9a33cc763be891", "testCaseId": "8c3ca9784f7a20f46f527b41c7204e5a", "fullName": "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "组织管理"}, {"name": "story", "value": "保存组织参数"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-老张"}, {"name": "parentSuite", "value": "test_case.test_mirZhang"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_mirZhang.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/35f86238-221e-489a-872c-4fc18caf0733-container.json

+{"uuid": "f30fcc8e-d327-4201-9cae-818c1562de14", "befores": [{"name": "module_name", "status": "passed", "start": 1716272619382, "stop": 1716272619382}], "start": 1716272619382, "stop": 1716272619577}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/35fdad53-8fab-4465-afe0-589d240772ff-container.json

+{"uuid": "0c560d5a-43eb-4711-9317-29f086428205", "befores": [{"name": "module_name", "status": "passed", "start": 1716272635750, "stop": 1716272635751}], "start": 1716272635750, "stop": 1716272635940}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/3627aa3a-87fb-45a3-978c-18906741d037-container.json

+{"uuid": "83399664-5cbc-44e0-86ff-877a536e99f5", "befores": [{"name": "url", "status": "passed", "start": 1716272635751, "stop": 1716272635751}], "start": 1716272635751, "stop": 1716272635938}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/367f7f26-b605-44a8-83d3-d0084b8b3d49-container.json

+{"uuid": "d0fa569a-ad2d-4a5c-b59c-4ba7513c5a1c", "befores": [{"name": "api_name", "status": "passed", "start": 1716272606163, "stop": 1716272606163}], "start": 1716272606163, "stop": 1716272606227}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/3705f94f-84f4-46e4-82a5-3c3db45340a5-result.json

+{"name": "正向用例", "status": "passed", "attachments": [{"name": "log", "source": "b8419b7a-abb7-4191-8966-fb43f086596d-attachment.txt", "type": "text/plain"}, {"name": "stdout", "source": "db394d98-cdaa-42a6-bd10-49adba7739a5-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'组织管理'"}, {"name": "api_name", "value": "'删除组织'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'高'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/org/v1/org/deleteOrg'"}, {"name": "mime", "value": "'text/plain'"}, {"name": "case_data", "value": "'test_add_org'"}, {"name": "expect_data", "value": "{'state': True, 'message': '删除组织成功！', 'value': ''}"}, {"name": "sql_data", "value": "None"}, {"name": "sql_type", "value": "None"}, {"name": "update_key", "value": "None"}], "start": 1716272621920, "stop": 1716272621978, "uuid": "0915e949-e043-45d1-9ca3-6935cdc3d192", "historyId": "db26a6f22fbc123482ea90d3e77fa9fd", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "组织管理"}, {"name": "story", "value": "删除组织"}, {"name": "severity", "value": "高"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/373ac105-669e-4271-b3b7-c140b9500cf7-container.json

+{"uuid": "cbc9e70d-ff4e-4d08-b12b-eaa451a5fded", "befores": [{"name": "case_level", "status": "passed", "start": 1716272626206, "stop": 1716272626206}], "start": 1716272626206, "stop": 1716272626352}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/3786a5ef-ed10-47e7-93ce-d6df6da3e11f-container.json

+{"uuid": "28072bd9-2002-4929-95ab-82b1327e5ffe", "befores": [{"name": "case_data", "status": "passed", "start": 1716272621795, "stop": 1716272621795}], "start": 1716272621795, "stop": 1716272621849}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/37aa29ac-4bc5-4557-bcf6-b70f8a27fea7-container.json

+{"uuid": "3c8852db-97dd-4c72-bd0c-1af4c3bbb4ea", "befores": [{"name": "mime", "status": "passed", "start": 1716272653520, "stop": 1716272653520}], "start": 1716272653520, "stop": 1716272653671}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/37d075f6-e1a7-4fe5-9bc3-b8e7d4aa4f3c-container.json

+{"uuid": "bc537dc9-fced-4e6b-ae6f-8b73efa7fe03", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272644557, "stop": 1716272644557}], "start": 1716272644557, "stop": 1716272644749}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/382d6e0d-8fb2-4305-8fe6-2901e801efa7-container.json

+{"uuid": "8b5807db-249a-4c82-8271-1f01070d604a", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272598747, "stop": 1716272598747}], "start": 1716272598747, "stop": 1716272598822}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/38c8f69a-da86-4577-89ad-3d3577b20e33-container.json

+{"uuid": "1077ac41-4b43-48d9-97b3-2256be3b1189", "befores": [{"name": "api_name", "status": "passed", "start": 1716272628365, "stop": 1716272628365}], "start": 1716272628365, "stop": 1716272628513}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/38ee662e-b84a-49a9-a6fa-84ae68f10447-container.json

+{"uuid": "e5295bc7-54eb-4467-bea3-aec13d40da36", "befores": [{"name": "url", "status": "passed", "start": 1716272644958, "stop": 1716272644958}], "start": 1716272644958, "stop": 1716272645064}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/39546673-81db-4c23-a67c-09b54e600122-container.json

+{"uuid": "a4402991-19d3-4fbc-bff1-e53350791df5", "befores": [{"name": "case_level", "status": "passed", "start": 1716272644557, "stop": 1716272644557}], "start": 1716272644557, "stop": 1716272644751}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/39d1b4b9-1b8a-4c1a-881b-411ee298f2b6-container.json

+{"uuid": "654ca142-d61f-442c-b33b-93f28d6bc51c", "befores": [{"name": "update_key", "status": "passed", "start": 1716272606163, "stop": 1716272606163}], "start": 1716272606163, "stop": 1716272606223}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/3a1ca18b-876c-44b5-824d-33fda3bbe9db-result.json

+{"name": "反向用例-密码正确,用户名为特殊字符", "status": "passed", "attachments": [{"name": "log", "source": "bcc2e3b2-a522-4515-87b3-73e3ac8c7b3d-attachment.txt", "type": "text/plain"}, {"name": "stdout", "source": "4fb9e02a-f4dd-4509-b0bf-c6e1ffb3332e-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'认证接口'"}, {"name": "api_name", "value": "'登录系统'"}, {"name": "case_title", "value": "'反向用例-密码正确,用户名为特殊字符'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/auth'"}, {"name": "mime", "value": "'json'"}, {"name": "case_data", "value": "{'username': '☯㍿卍卐', 'password': 'MTIzNDU2'}"}, {"name": "expect_data", "value": "{'message': '账号或密码错误'}"}, {"name": "sql_data", "value": "None"}, {"name": "sql_type", "value": "None"}, {"name": "update_key", "value": "None"}], "start": 1716272599527, "stop": 1716272599627, "uuid": "817d0d0b-74b8-4790-b30a-5b191bfb34b5", "historyId": "fa305c7b3d900250c6115572baa5540a", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "认证接口"}, {"name": "story", "value": "登录系统"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/3a53c65c-8b58-4ffd-b084-4aef4c7d6fcd-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功", "trace": "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "fe30cb30-283a-4756-bad3-66f16f9905d7-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'组织管理'"}, {"name": "api_name", "value": "'添加组织'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'高'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/org/v1/org/addOrg'"}, {"name": "mime", "value": "'json'"}, {"name": "case_data", "value": "{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}"}, {"name": "expect_data", "value": "{'message': '添加组织成功'}"}, {"name": "sql_data", "value": "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}"}, {"name": "sql_type", "value": "'select|delete'"}, {"name": "update_key", "value": "'demId'"}], "start": 1716272617174, "stop": 1716272617355, "uuid": "381f3194-e48e-497d-b373-b9ef2687c022", "historyId": "487ae598a2b30a5ea2489bb3e5fa08a4", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "组织管理"}, {"name": "story", "value": "添加组织"}, {"name": "severity", "value": "高"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/3aa47fe4-a88b-4297-9ed5-0fec60475058-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '刷新token成功' == None\n +  where None = <built-in method get of dict object at 0x0000014F191B6B40>('message')\n +    where <built-in method get of dict object at 0x0000014F191B6B40> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwNH0.TOXPdeAD96XQ_Maa-ITQDDQZTnKhlW09esTDC6-C8_Wux9HSk3bWURoOvhmcidK-lCj4Tvw1ZO0dYFWGR8-lsg', 'userAttrs': {}, ...}.get\n +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwNH0.TOXPdeAD96XQ_Maa-ITQDDQZTnKhlW09esTDC6-C8_Wux9HSk3bWURoOvhmcidK-lCj4Tvw1ZO0dYFWGR8-lsg', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\n +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json", "trace": "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '刷新token成功' == None\nE                +  where None = <built-in method get of dict object at 0x0000014F191B6B40>('message')\nE                +    where <built-in method get of dict object at 0x0000014F191B6B40> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwNH0.TOXPdeAD96XQ_Maa-ITQDDQZTnKhlW09esTDC6-C8_Wux9HSk3bWURoOvhmcidK-lCj4Tvw1ZO0dYFWGR8-lsg', 'userAttrs': {}, ...}.get\nE                +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwNH0.TOXPdeAD96XQ_Maa-ITQDDQZTnKhlW09esTDC6-C8_Wux9HSk3bWURoOvhmcidK-lCj4Tvw1ZO0dYFWGR8-lsg', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\nE                +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "d993550e-3284-4071-9240-5f178c323d76-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'认证接口'"}, {"name": "api_name", "value": "'刷新token'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'GET'"}, {"name": "url", "value": "'http://120.46.172.186:8080/refresh'"}, {"name": "mime", "value": "None"}, {"name": "case_data", "value": "None"}, {"name": "expect_data", "value": "{'message': '刷新token成功'}"}, {"name": "sql_data", "value": "None"}, {"name": "sql_type", "value": "None"}, {"name": "update_key", "value": "None"}], "start": 1716272606164, "stop": 1716272606215, "uuid": "f2e2b9d9-5e33-490f-abbc-6e66baca6bd7", "historyId": "1dcae5f805bddffd6ce19e14c8b3458b", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "认证接口"}, {"name": "story", "value": "刷新token"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/3ab28b4d-d994-4fd7-8877-af44a0ad2ebf-container.json

+{"uuid": "e21840ec-210e-48b6-9c79-b99232b7984c", "befores": [{"name": "method", "status": "passed", "start": 1716272621598, "stop": 1716272621598}], "start": 1716272621598, "stop": 1716272621789}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/3aea0f47-b834-47ab-b607-cf69a1355ce0-container.json

+{"uuid": "a2ba43f4-8407-4e73-88e9-9924e405a364", "befores": [{"name": "case_title", "status": "passed", "start": 1716272598997, "stop": 1716272598997}], "start": 1716272598997, "stop": 1716272599098}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/3b15f97a-82a9-4898-934d-abb216200416-container.json

+{"uuid": "e4e2be24-bd50-411f-882f-e37d4133736d", "befores": [{"name": "case_data", "status": "passed", "start": 1716272644557, "stop": 1716272644557}], "start": 1716272644557, "stop": 1716272644749}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/3b86a48c-e9ff-45dc-a7ca-8a5f178df007-container.json

+{"uuid": "5183bf3f-2fb8-4156-b251-64c159396825", "befores": [{"name": "url", "status": "passed", "start": 1716272599315, "stop": 1716272599315}], "start": 1716272599315, "stop": 1716272599411}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/3ce98c9a-8e9b-4316-9ef5-271dbab64554-container.json

+{"uuid": "d36729dc-c93f-41c1-9289-10e4bed07cc0", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272599527, "stop": 1716272599527}], "start": 1716272599527, "stop": 1716272599630}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/3d13a08f-69e0-411e-b723-af91e303d5f3-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTg5OTgsImlhdCI6MTcxNjI3MjU5OH0.4JgpWuf9sSQnYV9dPIhf0I76OkCqUlLws0abjIB0nEM_iXrT2qd79jiUvk3kiwUvDIw9aHYQdvVjAFq8AQLNCw","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDAsImlhdCI6MTcxNjI3MjYwMH0.atAGdmkk-bhC9iAhggDWp0VlgVLl39hN3_u2ytWqmjm1GWT-vhDYRgCax56GrBuR6EkPJEseXgX-S8EfzoWXhg","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDIsImlhdCI6MTcxNjI3MjYwMn0.2ULfoTRcxys6pnuEKjHxZH4GI20D2qBisJFYoBn2GdZLw23Xapl1u2ATzI1w5cFlBcJf3_bFyVN7eo7OfOOMUg","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/3d323704-b61d-402c-9a9e-56228930d577-container.json

+{"uuid": "cd64653a-7ed6-4e1a-babb-437b8f0a2231", "befores": [{"name": "method", "status": "passed", "start": 1716272644817, "stop": 1716272644817}], "start": 1716272644817, "stop": 1716272644877}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/3e1dddd4-a50e-4a93-82ab-380a7f6a2a05-container.json

+{"uuid": "4ba1c4c4-31fb-49f0-81af-aab4c6d1453a", "befores": [{"name": "api_name", "status": "passed", "start": 1716272621920, "stop": 1716272621920}], "start": 1716272621920, "stop": 1716272621983}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/3e44b05f-a29b-42ca-a981-6077ee27639d-container.json

+{"uuid": "178ec5ca-bc0e-4f5b-a5e9-a11490339fa8", "befores": [{"name": "case_level", "status": "passed", "start": 1716272619383, "stop": 1716272619383}], "start": 1716272619383, "stop": 1716272619577}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/3f4f6bfd-2c97-4067-a7d0-c838b6985874-container.json

+{"uuid": "ccfa4553-7bef-4946-aa23-452a0037e1e8", "befores": [{"name": "case_data", "status": "passed", "start": 1716272604094, "stop": 1716272604094}], "start": 1716272604094, "stop": 1716272604154}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/3f507870-023d-4574-bb9f-ac551fe2c56d-attachment.txt

+用例函数1

InterfaceAutoTest/report/allure/json/3fe7d2e2-065e-4efe-a886-21368a47c111-container.json

+{"uuid": "66faac36-79fe-4200-8856-0bc8b260728d", "befores": [{"name": "update_key", "status": "passed", "start": 1716272628365, "stop": 1716272628365}], "start": 1716272628365, "stop": 1716272628508}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/3fea5037-15b0-4c70-94fd-406fc19edfa4-container.json

+{"uuid": "b8349119-e1a9-43fb-b474-b85e42717670", "befores": [{"name": "module_name", "status": "passed", "start": 1716272651356, "stop": 1716272651356}], "start": 1716272651356, "stop": 1716272651504}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/40099d67-ed4b-4b82-9147-fafe05e0e8e8-container.json

+{"uuid": "e44ae17f-53e3-4eeb-bb1e-901d645dcf7f", "befores": [{"name": "module_name", "status": "passed", "start": 1716272632685, "stop": 1716272632685}], "start": 1716272632685, "stop": 1716272632841}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/401078b7-b792-412b-a290-daca8134cc1e-container.json

+{"uuid": "ef992a95-c78f-40cf-ba61-f438f58a0166", "befores": [{"name": "method", "status": "passed", "start": 1716272612749, "stop": 1716272612749}], "start": 1716272612749, "stop": 1716272612949}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/4141671e-3bbe-434d-847a-8ed3780c884f-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803532844318720"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803541883043840"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803550955323392"}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/41a027bb-de1e-4b53-b02e-df5833a08d8f-container.json

+{"uuid": "423cfde0-acd4-429a-bb37-f43d2d8b121b", "befores": [{"name": "method", "status": "passed", "start": 1716272599102, "stop": 1716272599102}], "start": 1716272599102, "stop": 1716272599207}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/41f53679-1aed-40d7-a41f-c6374c83d3b1-container.json

+{"uuid": "e641d3dc-2e68-4113-8173-3de563a6e953", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272604095, "stop": 1716272604095}], "start": 1716272604095, "stop": 1716272604154}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/4223532c-4618-4747-be31-0c025db8c507-container.json

+{"uuid": "e817c012-e377-4407-afe6-81a21fee697f", "befores": [{"name": "mime", "status": "passed", "start": 1716272606163, "stop": 1716272606163}], "start": 1716272606163, "stop": 1716272606225}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/433a7182-693f-4a9e-a1ce-666e6aff5d53-container.json

+{"uuid": "ab7849fb-32f3-4ced-9ce0-0e1f99141100", "befores": [{"name": "mime", "status": "passed", "start": 1716272644958, "stop": 1716272644958}], "start": 1716272644958, "stop": 1716272645063}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/435ca50d-b0b7-4a37-921a-aa439169851b-container.json

+{"uuid": "b14b25ed-1117-4a8f-89a4-38a1c3380f63", "befores": [{"name": "module_name", "status": "passed", "start": 1716272610325, "stop": 1716272610325}], "start": 1716272610324, "stop": 1716272610394}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/437a58a5-d5d5-483e-b15f-9b17afd0b873-container.json

+{"uuid": "cd68733f-6d5c-480d-89a1-5c2a278e3bfd", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272621855, "stop": 1716272621856}], "start": 1716272621855, "stop": 1716272621913}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/43c8e4c4-deb1-467b-8b13-cd9a4bbefbf2-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功", "trace": "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "05510126-4185-4429-ade2-1f1e848033c5-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'组织管理'"}, {"name": "api_name", "value": "'添加组织'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'高'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/org/v1/org/addOrg'"}, {"name": "mime", "value": "'json'"}, {"name": "case_data", "value": "{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}"}, {"name": "expect_data", "value": "{'message': '添加组织成功'}"}, {"name": "sql_data", "value": "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}"}, {"name": "sql_type", "value": "'select|delete'"}, {"name": "update_key", "value": "'demId'"}], "start": 1716272614968, "stop": 1716272615147, "uuid": "4acfa501-2cbd-4297-a954-977a5c0e666c", "historyId": "487ae598a2b30a5ea2489bb3e5fa08a4", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "组织管理"}, {"name": "story", "value": "添加组织"}, {"name": "severity", "value": "高"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/441229d2-ab22-4dce-90f6-9ae157880e78-container.json

+{"uuid": "21b0a644-b7ae-4c36-8076-079cc4044af7", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272599103, "stop": 1716272599103}], "start": 1716272599103, "stop": 1716272599205}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/44db8f00-7c4e-4d03-9460-4fa54b70b596-container.json

+{"uuid": "d8200888-f778-42ef-91d8-3bd7078edd9b", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272598893, "stop": 1716272598893}], "start": 1716272598893, "stop": 1716272598990}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/453d75c3-446a-43a8-9e16-df66d3772d52-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功", "trace": "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "e62cc822-0620-41c7-8bb5-0b63878d429c-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'组织管理'"}, {"name": "api_name", "value": "'添加组织'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'高'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/org/v1/org/addOrg'"}, {"name": "mime", "value": "'json'"}, {"name": "case_data", "value": "{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}"}, {"name": "expect_data", "value": "{'message': '添加组织成功'}"}, {"name": "sql_data", "value": "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}"}, {"name": "sql_type", "value": "'select|delete'"}, {"name": "update_key", "value": "'demId'"}], "start": 1716272644557, "stop": 1716272644742, "uuid": "301a3d4e-adda-4839-a59e-f832c89915e5", "historyId": "526f1fd519b78b4955668d6cfd277048", "testCaseId": "8c3ca9784f7a20f46f527b41c7204e5a", "fullName": "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "组织管理"}, {"name": "story", "value": "添加组织"}, {"name": "severity", "value": "高"}, {"name": "epic", "value": "BPM系统-老张"}, {"name": "parentSuite", "value": "test_case.test_mirZhang"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_mirZhang.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/4550821a-c2ec-480e-98f0-9ce92e2b6c5a-container.json

+{"uuid": "595229c1-ac68-4893-abf7-26b78a3d7c16", "befores": [{"name": "method", "status": "passed", "start": 1716272624098, "stop": 1716272624098}], "start": 1716272624098, "stop": 1716272624196}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/45dda0f9-73da-4e10-9a82-e45527384615-container.json

+{"uuid": "197eefb6-d3c6-4cd9-a705-778473c2b5a7", "befores": [{"name": "api_name", "status": "passed", "start": 1716272633396, "stop": 1716272633396}], "start": 1716272633396, "stop": 1716272633540}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/4640328e-1256-4159-a8f6-25306a2a06c3-container.json

+{"uuid": "e689a4f6-9881-4c85-bd24-61cb571737f6", "befores": [{"name": "module_name", "status": "passed", "start": 1716272644557, "stop": 1716272644557}], "start": 1716272644557, "stop": 1716272644752}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/4711e424-1263-4cc2-bfb0-3057fc9eea7c-container.json

+{"uuid": "58287a3d-2406-4e03-b0fd-eea8395c04fd", "befores": [{"name": "case_data", "status": "passed", "start": 1716272619383, "stop": 1716272619383}], "start": 1716272619383, "stop": 1716272619576}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/47527694-d947-4dde-8555-fc175053b7e3-container.json

+{"uuid": "eaf8aee2-770f-413b-b3d4-0e24d3eade28", "befores": [{"name": "module_name", "status": "passed", "start": 1716272630525, "stop": 1716272630525}], "start": 1716272630525, "stop": 1716272630671}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/478a7aac-5f8d-472a-ac3c-381ef3d98b4f-container.json

+{"uuid": "1b397646-ce33-49b8-aef8-a309fa27be53", "befores": [{"name": "case_data", "status": "passed", "start": 1716272647081, "stop": 1716272647081}], "start": 1716272647081, "stop": 1716272647181}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/484ee469-3234-4c63-9c7f-309831f7819c-result.json

+{"name": "反向用例-密码正确,用户名错误", "status": "passed", "attachments": [{"name": "log", "source": "210b12cf-948c-46d4-821a-7932288435ae-attachment.txt", "type": "text/plain"}, {"name": "stdout", "source": "ff716806-b915-4865-a3fd-98f53bde6547-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'认证接口'"}, {"name": "api_name", "value": "'登录系统'"}, {"name": "case_title", "value": "'反向用例-密码正确,用户名错误'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/auth'"}, {"name": "mime", "value": "'application/json'"}, {"name": "case_data", "value": "{'username': 'admin123', 'password': 'MTIzNDU2'}"}, {"name": "expect_data", "value": "{'message': '账号或密码错误'}"}, {"name": "sql_data", "value": "None"}, {"name": "sql_type", "value": "None"}, {"name": "update_key", "value": "None"}], "start": 1716272599640, "stop": 1716272599737, "uuid": "f77df4b9-85f7-4608-a188-2bf4343d4a14", "historyId": "83d67cdc5550a580709b5379b214757d", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "认证接口"}, {"name": "story", "value": "登录系统"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/485f6065-5e7c-4e5e-a66f-ecc32f5566ef-container.json

+{"uuid": "2b7f0238-0114-4875-bbd3-57c1aeac40e2", "befores": [{"name": "mime", "status": "passed", "start": 1716272651357, "stop": 1716272651357}], "start": 1716272651357, "stop": 1716272651501}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/48712791-b121-4c6d-95e3-f3080aa82ce7-container.json

+{"uuid": "8d6c6bdb-55bd-49b9-b997-4845d1779fb0", "befores": [{"name": "api_name", "status": "passed", "start": 1716272604094, "stop": 1716272604094}], "start": 1716272604094, "stop": 1716272604156}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/48f77128-b161-4345-9237-c91960154fa2-container.json

+{"uuid": "37f9f6a7-ad29-493c-8e02-c7afc5b8e0d9", "befores": [{"name": "api_name", "status": "passed", "start": 1716272610325, "stop": 1716272610325}], "start": 1716272610325, "stop": 1716272610394}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/498a902e-9d53-41db-8dc2-21e4115774f6-container.json

+{"uuid": "14e3f9ba-33f6-4b1d-bb6a-49e33c7d59ac", "befores": [{"name": "url", "status": "passed", "start": 1716272642364, "stop": 1716272642365}], "start": 1716272642364, "stop": 1716272642550}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/4a076bdd-f4d5-4893-ac61-6b2de36be067-container.json

+{"uuid": "9b3c025c-897f-4738-bed7-2353ca13f8e5", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272619383, "stop": 1716272619383}], "start": 1716272619383, "stop": 1716272619574}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/4aca2377-c465-44c3-8a41-c4bf29398c90-container.json

+{"uuid": "0426e7bb-5ce1-443f-bb21-ac398eb28df8", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272624098, "stop": 1716272624098}], "start": 1716272624098, "stop": 1716272624193}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/4bca01be-8d70-403a-9bbe-996fd2a04700-container.json

+{"uuid": "54b93657-eb8f-4029-acda-6823d7826df1", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272610325, "stop": 1716272610325}], "start": 1716272610325, "stop": 1716272610391}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/4bcb6226-c1aa-4031-bbd9-a0fb2c8c397a-attachment.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'username': '', 'password': 'MTIzNDU2'}, 期望数据为:{'message': '账号或密码错误'}, 服务器返回的数据为：{"state":false,"message":"账号或密码错误","logId":"1792803332075569152"}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/4bee1565-ae76-4818-a667-087d24c27356-attachment.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'username': 'adminadminadminadmin', 'password': 'MTIzNDU2'}, 期望数据为:{'message': '账号或密码错误'}, 服务器返回的数据为：{"state":false,"message":"账号或密码错误","logId":"1792803332507582464"}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/4bf9f46a-4e61-4823-b125-d546c964490c-container.json

+{"uuid": "5c241130-dce7-4d9a-87e2-6573f864bba4", "befores": [{"name": "case_data", "status": "passed", "start": 1716272649196, "stop": 1716272649196}], "start": 1716272649196, "stop": 1716272649336}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/4e1a21dd-57fa-4229-ae57-68f81a484357-container.json

+{"uuid": "0c1cac1d-56dd-4779-be63-d84cab44f7cb", "befores": [{"name": "update_key", "status": "passed", "start": 1716272644557, "stop": 1716272644557}], "start": 1716272644557, "stop": 1716272644748}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/4e7ca8f1-7763-4021-a2cf-1a11e98698b0-container.json

+{"uuid": "5cf23044-d2f0-4677-b25f-ff622474a2ad", "befores": [{"name": "url", "status": "passed", "start": 1716272632685, "stop": 1716272632685}], "start": 1716272632685, "stop": 1716272632839}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/4ec93c50-7587-47a9-b8f7-b300b82cf0e3-container.json

+{"uuid": "5da97f00-bdf6-490b-bbf7-3956e833e9d6", "befores": [{"name": "case_title", "status": "passed", "start": 1716272621986, "stop": 1716272621986}], "start": 1716272621986, "stop": 1716272622090}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/4eff655b-17a5-43cf-b160-3295f0569c16-container.json

+{"uuid": "4368da7c-d47d-41dc-9437-b077e7a3ab24", "befores": [{"name": "method", "status": "passed", "start": 1716272599417, "stop": 1716272599418}], "start": 1716272599417, "stop": 1716272599522}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/4f123ded-0b4f-415d-961e-3f0c77fa19a2-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803532844318720"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803541883043840"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803550955323392"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803560044380160"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803569104076800"}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/4fb87a6d-e78a-458c-9cba-f37bf1569ca4-container.json

+{"uuid": "4e379f8e-f135-4535-a401-448b03983558", "befores": [{"name": "update_key", "status": "passed", "start": 1716272632685, "stop": 1716272632685}], "start": 1716272632685, "stop": 1716272632827}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/4fb9e02a-f4dd-4509-b0bf-c6e1ffb3332e-attachment.txt

+断言

InterfaceAutoTest/report/allure/json/4fc10305-fb29-4652-986e-b804da2b41dc-container.json

+{"uuid": "80766b16-93f2-4bd1-8621-f368a16cdc94", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272644958, "stop": 1716272644958}], "start": 1716272644958, "stop": 1716272645061}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/4fc57b0e-88e2-4150-a1a0-afa2c27af05c-attachment.txt

+断言

InterfaceAutoTest/report/allure/json/4fe30381-aa29-4a12-8619-2fbbd155caee-container.json

+{"uuid": "fb923434-d664-4867-af21-2498005e86e6", "befores": [{"name": "module_name", "status": "passed", "start": 1716272608242, "stop": 1716272608243}], "start": 1716272608242, "stop": 1716272608307}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/505c1995-4d9d-4aad-9c85-4bcf76c2c950-container.json

+{"uuid": "31d1db9d-6fd5-40d4-a433-81bea31b1b64", "befores": [{"name": "case_title", "status": "passed", "start": 1716272617172, "stop": 1716272617172}], "start": 1716272617172, "stop": 1716272617364}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/5157fe77-24b5-474e-9f59-f2f5f3d14c0b-container.json

+{"uuid": "975cf4b0-4375-4670-97e7-ad34a04a1b93", "befores": [{"name": "case_data", "status": "passed", "start": 1716272635751, "stop": 1716272635751}], "start": 1716272635751, "stop": 1716272635937}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/5194993c-953c-4347-b396-869254ffbd70-container.json

+{"uuid": "41566d67-7ffb-4509-beed-b9a7a3ea3c93", "befores": [{"name": "case_level", "status": "passed", "start": 1716272621794, "stop": 1716272621794}], "start": 1716272621794, "stop": 1716272621851}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/51c9a8ff-e014-4e33-8a03-0a3ce8303b71-container.json

+{"uuid": "c2fb2b6b-bc24-4c81-84d1-59578bde4abc", "befores": [{"name": "update_key", "status": "passed", "start": 1716272653522, "stop": 1716272653522}], "start": 1716272653522, "stop": 1716272653667}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/51d2db2f-bb97-4b47-b86b-1a6cc9e37dea-container.json

+{"uuid": "4f57e710-83cb-4ff5-8336-0780cdccbb06", "befores": [{"name": "case_data", "status": "passed", "start": 1716272644958, "stop": 1716272644958}], "start": 1716272644958, "stop": 1716272645063}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/51d7ee0f-70b7-4b5e-ae03-59ded1dddda6-container.json

+{"uuid": "642b7d09-554f-49f9-84dd-964c48065753", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272598828, "stop": 1716272598828}], "start": 1716272598828, "stop": 1716272598887}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/51e91ffe-f103-478d-8759-70de7531dc1c-container.json

+{"uuid": "a1f95261-4f04-4816-8705-65be185cd2c4", "befores": [{"name": "case_level", "status": "passed", "start": 1716272599212, "stop": 1716272599212}], "start": 1716272599212, "stop": 1716272599310}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/525dbc2f-e208-4f14-a9be-f5f04ae9e1af-container.json

+{"uuid": "39ab2baa-324f-4552-b8e0-30b16d2e1546", "befores": [{"name": "module_name", "status": "passed", "start": 1716272599526, "stop": 1716272599526}], "start": 1716272599526, "stop": 1716272599634}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/534bedd0-35b6-4687-a631-35b9f700d10b-result.json

+{"name": "反向用例-用户名正确,密码为特殊字符", "status": "passed", "attachments": [{"name": "log", "source": "26060cd5-287d-410f-ab2e-8814868b5d88-attachment.txt", "type": "text/plain"}, {"name": "stdout", "source": "5955ba8e-11d9-4edb-aa40-14fd224d434f-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'认证接口'"}, {"name": "api_name", "value": "'登录系统'"}, {"name": "case_title", "value": "'反向用例-用户名正确,密码为特殊字符'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/auth'"}, {"name": "mime", "value": "'application/json'"}, {"name": "case_data", "value": "{'username': 'admin', 'password': '☯㍿卍卐'}"}, {"name": "expect_data", "value": "{'message': '账号或密码错误'}"}, {"name": "sql_data", "value": "None"}, {"name": "sql_type", "value": "None"}, {"name": "update_key", "value": "None"}], "start": 1716272599103, "stop": 1716272599203, "uuid": "f65700d8-3d1e-41a8-a793-c4ce8afbf632", "historyId": "45fbe766301d5f34f2314154dd48ad7c", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "认证接口"}, {"name": "story", "value": "登录系统"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/53d545bb-50c4-45b4-8cfc-283bc7768165-container.json

+{"uuid": "db53b751-0d2a-4652-9a42-2dc65fad4bf1", "befores": [{"name": "url", "status": "passed", "start": 1716272606163, "stop": 1716272606163}], "start": 1716272606163, "stop": 1716272606225}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/5404424f-baa9-4e0a-b055-58b4d0891cea-container.json

+{"uuid": "e4b16d18-56a7-492c-bc8b-9d5761ebd47f", "befores": [{"name": "mime", "status": "passed", "start": 1716272637955, "stop": 1716272637955}], "start": 1716272637955, "stop": 1716272638147}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/5489705e-8dea-4752-ad63-59783a8eb13e-container.json

+{"uuid": "50fccad0-08c9-416f-92b3-846e71ab3006", "befores": [{"name": "url", "status": "passed", "start": 1716272602023, "stop": 1716272602023}], "start": 1716272602023, "stop": 1716272602082}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/551409fa-a940-42de-ac01-01fa8391a370-container.json

+{"uuid": "f58b7a46-28bf-43bf-a226-b0cf9835a726", "befores": [{"name": "module_name", "status": "passed", "start": 1716272617172, "stop": 1716272617172}], "start": 1716272617172, "stop": 1716272617365}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/554b29db-ba97-4957-bcd9-60b739600ddc-container.json

+{"uuid": "bd5c757a-3c90-41ea-a63e-72cc2d42fa00", "befores": [{"name": "mime", "status": "passed", "start": 1716272621920, "stop": 1716272621920}], "start": 1716272621920, "stop": 1716272621982}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/556f61ba-04bb-43d6-a86e-b19974fa68da-container.json

+{"uuid": "82d16806-b5a8-42e7-97d4-81e889338395", "befores": [{"name": "mime", "status": "passed", "start": 1716272610541, "stop": 1716272610541}], "start": 1716272610541, "stop": 1716272610735}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/55edf448-186a-4ca0-969d-06fa0f5881f4-container.json

+{"uuid": "0e0b42f9-66af-4389-8e3e-e2f295c1c3e0", "befores": [{"name": "case_title", "status": "passed", "start": 1716272621855, "stop": 1716272621855}], "start": 1716272621855, "stop": 1716272621916}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/560e2112-de89-41b0-9f50-2b4a3c3f02a7-container.json

+{"uuid": "72351db0-2597-4a6b-82a9-cfe8b1140031", "befores": [{"name": "case_level", "status": "passed", "start": 1716272633543, "stop": 1716272633543}], "start": 1716272633543, "stop": 1716272633730}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/56308eb6-c1b5-4c6a-8238-ecf775b133d8-container.json

+{"uuid": "be7119ff-ac72-428f-9612-35e7103ad8fe", "befores": [{"name": "case_data", "status": "passed", "start": 1716272653522, "stop": 1716272653522}], "start": 1716272653520, "stop": 1716272653670}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/569365be-bc53-45e9-9e52-4aae3d7e1d84-container.json

+{"uuid": "d067337f-82f8-49ca-942b-96627d92ccf0", "befores": [{"name": "update_key", "status": "passed", "start": 1716272617174, "stop": 1716272617174}], "start": 1716272617174, "stop": 1716272617361}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/5728de4e-6dcb-4797-a840-91c53036baf5-container.json

+{"uuid": "c677cf0b-3b84-49a7-a199-cf77b2c06b47", "befores": [{"name": "url", "status": "passed", "start": 1716272644817, "stop": 1716272644817}], "start": 1716272644817, "stop": 1716272644877}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/5728e994-9050-4f22-b158-624a463ba527-container.json

+{"uuid": "aa6ef870-2ca1-44d8-be7a-7b866feb038b", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272635751, "stop": 1716272635751}], "start": 1716272635751, "stop": 1716272635937}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/5780227f-1dba-4b18-878d-673e4ce5c15b-container.json

+{"uuid": "31413685-a894-47ce-ab55-6eccfa3d541b", "befores": [{"name": "case_title", "status": "passed", "start": 1716272655684, "stop": 1716272655684}], "start": 1716272655684, "stop": 1716272655837}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/578f086f-7b0a-4fee-805a-ef8b1bd0b040-container.json

+{"uuid": "3708e63d-1549-442e-9e8b-1279a33eb902", "befores": [{"name": "case_level", "status": "passed", "start": 1716272644958, "stop": 1716272644958}], "start": 1716272644958, "stop": 1716272645065}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/580d7f08-2287-4602-ab48-551adc44dc16-container.json

+{"uuid": "2311c69f-83c9-44e0-a96a-6798f43e0801", "befores": [{"name": "update_key", "status": "passed", "start": 1716272610398, "stop": 1716272610398}], "start": 1716272610398, "stop": 1716272610534}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/58934555-7bf1-4cff-a8df-f730cf934db8-container.json

+{"uuid": "6a1b5e3b-8922-4a5a-bc67-fd2b1f7be158", "befores": [{"name": "case_level", "status": "passed", "start": 1716272633396, "stop": 1716272633396}], "start": 1716272633396, "stop": 1716272633538}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/58c5e196-7f2e-4e50-928d-f1eb5ac0eaaf-container.json

+{"uuid": "4a2d9e2c-d481-4eb7-8271-1c1be0b7f110", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272599639, "stop": 1716272599639}], "start": 1716272599639, "stop": 1716272599739}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/58d38278-cb51-4be7-b653-8aa744bd2b0a-container.json

+{"uuid": "345d57b4-53bc-4ca5-a5cc-ce4c36e62b4a", "befores": [{"name": "method", "status": "passed", "start": 1716272598997, "stop": 1716272598997}], "start": 1716272598997, "stop": 1716272599096}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/59481d4d-d8ba-4811-b36b-578534cd97d6-container.json

+{"uuid": "e0bb7d67-8ffe-4431-a1da-494a11c6b487", "befores": [{"name": "url", "status": "passed", "start": 1716272608243, "stop": 1716272608243}], "start": 1716272608243, "stop": 1716272608304}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/594a05ae-c86d-4fb3-87f2-79b09ed2be4a-container.json

+{"uuid": "3115a590-2081-4090-a8ad-dd0000829a20", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272610542, "stop": 1716272610542}], "start": 1716272610542, "stop": 1716272610733}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/5955ba8e-11d9-4edb-aa40-14fd224d434f-attachment.txt

+断言

InterfaceAutoTest/report/allure/json/59a4595a-ad1c-4f41-ab22-ee1767391b88-container.json

+{"uuid": "96703d11-9387-4703-9792-99a45d1fd90c", "befores": [{"name": "mime", "status": "passed", "start": 1716272635751, "stop": 1716272635751}], "start": 1716272635751, "stop": 1716272635938}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/59adae07-90ef-4d59-b5c7-d4fbd7978198-container.json

+{"uuid": "107db1e4-d45e-4db1-b8f3-9aa2920b0f4e", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272630526, "stop": 1716272630526}], "start": 1716272630526, "stop": 1716272630667}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/59e4754b-40b7-4e59-bf08-6f29f5bf36f8-container.json

+{"uuid": "a19ebe92-cb2d-4f4c-911f-0482a22b7e54", "befores": [{"name": "update_key", "status": "passed", "start": 1716272651357, "stop": 1716272651357}], "start": 1716272651357, "stop": 1716272651498}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/5a361386-9194-44c6-ac58-fb1f0f224f21-container.json

+{"uuid": "f5a35020-a7b5-4f17-a4cf-1cb87cab3fe7", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272630526, "stop": 1716272630526}], "start": 1716272630526, "stop": 1716272630668}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/5a99f589-27c4-49f4-8ca8-56fbe368aeb2-container.json

+{"uuid": "779e6ee8-f8ab-433c-99b5-33e3a7a51358", "befores": [{"name": "method", "status": "passed", "start": 1716272598893, "stop": 1716272598893}], "start": 1716272598893, "stop": 1716272598992}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/5aeb41f0-2af0-4c16-95da-592baacf26bb-container.json

+{"uuid": "ebca5792-a76f-4c68-829e-413fb9a4ab6f", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272644557, "stop": 1716272644557}], "start": 1716272644557, "stop": 1716272644749}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/5b20defa-d427-4a64-8d82-987cdedfb368-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功", "trace": "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "91d7907c-e255-4493-98f9-72ed7b720ce3-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'组织管理'"}, {"name": "api_name", "value": "'添加组织'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'高'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/org/v1/org/addOrg'"}, {"name": "mime", "value": "'json'"}, {"name": "case_data", "value": "{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}"}, {"name": "expect_data", "value": "{'message': '添加组织成功'}"}, {"name": "sql_data", "value": "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}"}, {"name": "sql_type", "value": "'select|delete'"}, {"name": "update_key", "value": "'demId'"}], "start": 1716272637956, "stop": 1716272638139, "uuid": "f34de71f-c617-47af-a35d-71c3f084dd08", "historyId": "526f1fd519b78b4955668d6cfd277048", "testCaseId": "8c3ca9784f7a20f46f527b41c7204e5a", "fullName": "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "组织管理"}, {"name": "story", "value": "添加组织"}, {"name": "severity", "value": "高"}, {"name": "epic", "value": "BPM系统-老张"}, {"name": "parentSuite", "value": "test_case.test_mirZhang"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_mirZhang.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/5b2dd8e8-4d26-4188-8bef-27fb912288bf-container.json

+{"uuid": "038029ab-1914-411a-adb3-1c9a043df212", "befores": [{"name": "api_name", "status": "passed", "start": 1716272644756, "stop": 1716272644756}], "start": 1716272644756, "stop": 1716272644812}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/5d6cb98b-64bf-4f2f-be74-5465c3ce28b4-container.json

+{"uuid": "de98d0b2-cb33-4029-87c5-0d2ee4947018", "befores": [{"name": "case_data", "status": "passed", "start": 1716272610397, "stop": 1716272610397}], "start": 1716272610397, "stop": 1716272610535}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/5da83498-f8c3-4af2-acb5-d86b9e9f0a43-container.json

+{"uuid": "ad841ebd-3200-4f67-8c65-7ce9bd91faf5", "befores": [{"name": "module_name", "status": "passed", "start": 1716272644882, "stop": 1716272644882}], "start": 1716272644882, "stop": 1716272644954}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/5de507a6-f3f4-4b42-989d-acf283299bda-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功", "trace": "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "207026aa-9909-4cbf-98c9-22cc531445cc-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'维度管理'"}, {"name": "api_name", "value": "'根据维度编码删除维度'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'DELETE'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'"}, {"name": "mime", "value": "'query'"}, {"name": "case_data", "value": "{'ids': '1792803379156631552'}"}, {"name": "expect_data", "value": "{'message': '删除维度成功'}"}, {"name": "sql_data", "value": "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"}, {"name": "sql_type", "value": "'select'"}, {"name": "update_key", "value": "'ids'"}], "start": 1716272632686, "stop": 1716272632817, "uuid": "0b751273-6918-4218-a296-0fb512c07b05", "historyId": "347d2f73ed73495ba7ba72dbf723f253", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "维度管理"}, {"name": "story", "value": "根据维度编码删除维度"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/5decca8c-38e2-47d9-a62f-338745509f3f-container.json

+{"uuid": "4eb8fc10-7c04-4d8e-a4c9-60a80d77a592", "befores": [{"name": "mime", "status": "passed", "start": 1716272644882, "stop": 1716272644882}], "start": 1716272644882, "stop": 1716272644951}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/5deebe9e-2009-46b3-b0a5-ab7e6a65bada-container.json

+{"uuid": "d3552944-039e-4212-9e3b-487562a3b1ef", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272599103, "stop": 1716272599103}], "start": 1716272599103, "stop": 1716272599205}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/5e00b12a-0776-4091-b684-8e917c2c1570-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功", "trace": "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "4141671e-3bbe-434d-847a-8ed3780c884f-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'维度管理'"}, {"name": "api_name", "value": "'根据维度编码删除维度'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'DELETE'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'"}, {"name": "mime", "value": "'query'"}, {"name": "case_data", "value": "{'ids': '1792803475629817856'}"}, {"name": "expect_data", "value": "{'message': '删除维度成功'}"}, {"name": "sql_data", "value": "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"}, {"name": "sql_type", "value": "'select'"}, {"name": "update_key", "value": "'ids'"}], "start": 1716272651358, "stop": 1716272651491, "uuid": "0c4ebf73-afc6-4ef9-8a2c-74c55cd751c9", "historyId": "f0f670cbfec7a9680aec241c756307a6", "testCaseId": "8c3ca9784f7a20f46f527b41c7204e5a", "fullName": "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "维度管理"}, {"name": "story", "value": "根据维度编码删除维度"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-老张"}, {"name": "parentSuite", "value": "test_case.test_mirZhang"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_mirZhang.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/5ea4af6a-29ff-4e59-b414-d3d899f3a16f-container.json

+{"uuid": "0a1a9b62-ec2f-4ffa-87d2-2574c2a1a12a", "befores": [{"name": "case_data", "status": "passed", "start": 1716272640166, "stop": 1716272640166}], "start": 1716272640166, "stop": 1716272640350}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/5eb0205d-c508-44c8-af94-4a2dbb6b9d17-container.json

+{"uuid": "41d4d1bc-ebfd-4e31-b2e3-87e0324c6774", "befores": [{"name": "case_data", "status": "passed", "start": 1716272598747, "stop": 1716272598747}], "start": 1716272598747, "stop": 1716272598822}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/5eb98e4d-e358-4357-82d5-c9a6a7f25e4d-container.json

+{"uuid": "19ac99dd-f2bc-4cee-9a1d-e4fd700bb63c", "befores": [{"name": "api_name", "status": "passed", "start": 1716272599314, "stop": 1716272599314}], "start": 1716272599314, "stop": 1716272599412}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/5f0b4ffa-a9a4-48f6-b6f1-66a5ae767e39-container.json

+{"uuid": "2b40c083-cabc-4e4f-adfb-e5adf758272f", "befores": [{"name": "case_title", "status": "passed", "start": 1716272649196, "stop": 1716272649196}], "start": 1716272649196, "stop": 1716272649338}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/5f4579e7-4490-4885-ba56-7692a8326889-result.json

+{"name": "添加维度-依赖登录", "status": "passed", "attachments": [{"name": "stdout", "source": "c76b71f1-72e8-4c61-b89a-9f691d8dbaa4-attachment.txt", "type": "text/plain"}], "start": 1716272632942, "stop": 1716272633094, "uuid": "b13de872-1e83-4039-bac4-c003649c8243", "historyId": "2c19ea97cbbe4cb31079c2ee05828120", "testCaseId": "2c19ea97cbbe4cb31079c2ee05828120", "fullName": "test_case.test_dependency.test_dependency#test_add_dem", "labels": [{"name": "feature", "value": "维度管理"}, {"name": "story", "value": "添加维度"}, {"name": "epic", "value": "BPM-场景测试"}, {"name": "tag", "value": "dependency(depends=['test_login'])"}, {"name": "parentSuite", "value": "test_case.test_dependency"}, {"name": "suite", "value": "test_dependency"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_dependency.test_dependency"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/6085357b-8307-4874-9d4b-408e479c4004-container.json

+{"uuid": "c17589df-28c1-477d-865d-048632b54684", "befores": [{"name": "url", "status": "passed", "start": 1716272599754, "stop": 1716272599754}], "start": 1716272599754, "stop": 1716272600008}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/613f5d4a-4034-44a9-9ba3-c580faf482f1-container.json

+{"uuid": "d4c589f1-1596-401e-9fcc-1ef1d151f894", "befores": [{"name": "method", "status": "passed", "start": 1716272604094, "stop": 1716272604094}], "start": 1716272604094, "stop": 1716272604155}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/6158a481-1f5e-46b0-97e7-a58f19ecc7ad-container.json

+{"uuid": "6846daf8-3329-47e7-8ce9-1e3698fe50e7", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272599418, "stop": 1716272599418}], "start": 1716272599418, "stop": 1716272599519}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/61f09805-c792-4ae5-b25e-832fbf1b6c8c-container.json

+{"uuid": "f66ac96b-b5bf-4ee5-b751-7367acef0f33", "befores": [{"name": "update_key", "status": "passed", "start": 1716272614968, "stop": 1716272614968}], "start": 1716272614968, "stop": 1716272615154}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/61fde0ef-1f43-4d1f-bbf5-62f8953773eb-container.json

+{"uuid": "fc2fb9af-f294-417d-baa4-9287c57c0465", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272610325, "stop": 1716272610325}], "start": 1716272610325, "stop": 1716272610391}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/6241145b-dcca-4001-8947-f539d7b52621-container.json

+{"uuid": "52388996-c93e-4e4b-b59d-ae500009ee8d", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272644817, "stop": 1716272644817}], "start": 1716272644817, "stop": 1716272644875}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/62a3bbed-68d8-4bd9-b2ba-24a2c2156b3d-container.json

+{"uuid": "b3e67c6a-8b57-464e-bcc8-4f45cb27e184", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272610325, "stop": 1716272610325}], "start": 1716272610325, "stop": 1716272610391}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/62f7e1f3-3808-4e92-b64e-d3e98aaca00e-container.json

+{"uuid": "09f60a5d-3c60-4f22-ade0-3ea2ba1fec32", "befores": [{"name": "module_name", "status": "passed", "start": 1716272604094, "stop": 1716272604094}], "start": 1716272604094, "stop": 1716272604157}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/630076a3-9c56-4537-a708-b76bc443e26f-container.json

+{"uuid": "b92ae42a-5a60-4120-9199-da23455427a2", "befores": [{"name": "api_name", "status": "passed", "start": 1716272599417, "stop": 1716272599417}], "start": 1716272599417, "stop": 1716272599523}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/63108350-1148-4126-adc4-a07a1c286cac-container.json

+{"uuid": "b5fea50c-9851-45b4-a470-c1e8d21a463e", "befores": [{"name": "mime", "status": "passed", "start": 1716272649196, "stop": 1716272649196}], "start": 1716272649196, "stop": 1716272649337}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/6370ca90-62b3-4b0c-b844-c15c56421073-container.json

+{"uuid": "0f13a881-8d30-469e-90cf-796564aac5f9", "befores": [{"name": "case_data", "status": "passed", "start": 1716272617174, "stop": 1716272617174}], "start": 1716272617174, "stop": 1716272617363}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/639ed518-df07-4093-a0ea-003d2fd921fe-container.json

+{"uuid": "4466df56-666d-4b60-ae45-e378fc250eba", "befores": [{"name": "case_level", "status": "passed", "start": 1716272599417, "stop": 1716272599417}], "start": 1716272599417, "stop": 1716272599522}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/63ed9fbf-6772-47c7-bc71-cc7c376a16d9-attachment.txt

+断言

InterfaceAutoTest/report/allure/json/641690dc-554a-4a04-be37-4a9e72b43fbb-attachment.txt

+断言

InterfaceAutoTest/report/allure/json/64389433-b94b-46a1-8e0a-c2a22ed22ab8-container.json

+{"uuid": "d4d60d9f-642b-4dd2-b598-937b86e421a6", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272598893, "stop": 1716272598893}], "start": 1716272598893, "stop": 1716272598990}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/646c2f82-8811-4ae3-bce3-a9b97a9f4d6f-container.json

+{"uuid": "a88aa9a6-20b5-41e0-ba2e-81159a1961cf", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272644958, "stop": 1716272644958}], "start": 1716272644958, "stop": 1716272645062}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/648254b5-5b8b-484f-9a9e-75a538118ff3-container.json

+{"uuid": "bc240ab8-e43f-4d75-81b8-6355378fc7d3", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272606163, "stop": 1716272606163}], "start": 1716272606163, "stop": 1716272606223}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/64a4bae0-ac1f-4b53-88b1-05ee3646f2d9-container.json

+{"uuid": "1a0144fa-4300-4aa8-8a32-920a4e79af09", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272647081, "stop": 1716272647081}], "start": 1716272647081, "stop": 1716272647180}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/64df2a49-4879-465f-9c4c-2dcda13fb2e0-container.json

+{"uuid": "49098221-64f9-4c29-be3a-224c043dfd9d", "befores": [{"name": "api_name", "status": "passed", "start": 1716272621598, "stop": 1716272621598}], "start": 1716272621598, "stop": 1716272621791}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/64e2a74f-d693-4476-b5d6-d4aec697e75f-attachment.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'username': 'admin', 'password': 'm'}, 期望数据为:{'message': '账号或密码错误'}, 服务器返回的数据为：{"state":false,"message":"账号或密码错误","logId":"1792803331177988096"}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/64e4edad-c631-4f71-a199-0c1a5b603ac1-container.json

+{"uuid": "c192d36b-68e3-4a87-a04b-7f18e9589763", "befores": [{"name": "url", "status": "passed", "start": 1716272610541, "stop": 1716272610541}], "start": 1716272610541, "stop": 1716272610735}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/6538a1c1-fce6-4dcb-8581-b6db9a84c0e5-container.json

+{"uuid": "5fb162f3-74f8-4a2f-9ac7-6ca2cc6a54f7", "befores": [{"name": "case_data", "status": "passed", "start": 1716272626206, "stop": 1716272626206}], "start": 1716272626206, "stop": 1716272626350}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/654344bd-5389-4267-afc9-86bfd0b489c7-container.json

+{"uuid": "ab6e2307-c7b9-42d7-ade2-f9b9b522747a", "befores": [{"name": "case_data", "status": "passed", "start": 1716272599754, "stop": 1716272599754}], "start": 1716272599754, "stop": 1716272600008}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/65b4c316-84d0-4121-87fa-81c2d0229fa0-container.json

+{"uuid": "65fe9779-6c66-4b6c-8eb2-2ec9c65c534f", "befores": [{"name": "case_title", "status": "passed", "start": 1716272633543, "stop": 1716272633543}], "start": 1716272633543, "stop": 1716272633732}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/668814eb-1425-48d2-b46c-7d923868caee-container.json

+{"uuid": "b151b397-1cf6-4623-9770-dffb0fb9cdf9", "befores": [{"name": "update_key", "status": "passed", "start": 1716272621856, "stop": 1716272621856}], "start": 1716272621856, "stop": 1716272621912}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/668d920f-e0e4-4dcf-9096-0436014c2977-container.json

+{"uuid": "3d7e74d1-7566-4cb7-8824-c68f126ea272", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272598893, "stop": 1716272598893}], "start": 1716272598893, "stop": 1716272598991}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/6746e627-6c89-4d4d-882c-498a31be9b1e-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '刷新token成功' == None\n +  where None = <built-in method get of dict object at 0x0000014F19157400>('message')\n +    where <built-in method get of dict object at 0x0000014F19157400> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwMn0.2ULfoTRcxys6pnuEKjHxZH4GI20D2qBisJFYoBn2GdZLw23Xapl1u2ATzI1w5cFlBcJf3_bFyVN7eo7OfOOMUg', 'userAttrs': {}, ...}.get\n +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwMn0.2ULfoTRcxys6pnuEKjHxZH4GI20D2qBisJFYoBn2GdZLw23Xapl1u2ATzI1w5cFlBcJf3_bFyVN7eo7OfOOMUg', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\n +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json", "trace": "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '刷新token成功' == None\nE                +  where None = <built-in method get of dict object at 0x0000014F19157400>('message')\nE                +    where <built-in method get of dict object at 0x0000014F19157400> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwMn0.2ULfoTRcxys6pnuEKjHxZH4GI20D2qBisJFYoBn2GdZLw23Xapl1u2ATzI1w5cFlBcJf3_bFyVN7eo7OfOOMUg', 'userAttrs': {}, ...}.get\nE                +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwMn0.2ULfoTRcxys6pnuEKjHxZH4GI20D2qBisJFYoBn2GdZLw23Xapl1u2ATzI1w5cFlBcJf3_bFyVN7eo7OfOOMUg', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\nE                +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "3d13a08f-69e0-411e-b723-af91e303d5f3-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'认证接口'"}, {"name": "api_name", "value": "'刷新token'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'GET'"}, {"name": "url", "value": "'http://120.46.172.186:8080/refresh'"}, {"name": "mime", "value": "None"}, {"name": "case_data", "value": "None"}, {"name": "expect_data", "value": "{'message': '刷新token成功'}"}, {"name": "sql_data", "value": "None"}, {"name": "sql_type", "value": "None"}, {"name": "update_key", "value": "None"}], "start": 1716272604095, "stop": 1716272604145, "uuid": "b0499f8b-a6d3-4f48-8305-789adf041ea8", "historyId": "1dcae5f805bddffd6ce19e14c8b3458b", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "认证接口"}, {"name": "story", "value": "刷新token"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/674782b5-95dd-437b-bbed-deec053e265f-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/6776052b-7e8b-4402-88bf-9082ecafdb36-container.json

+{"uuid": "3e6f45c9-c644-40ff-87a3-c1d7d9f45a11", "befores": [{"name": "case_title", "status": "passed", "start": 1716272647081, "stop": 1716272647081}], "start": 1716272647081, "stop": 1716272647183}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/67c2a574-6212-4e16-b8a8-de95c2a7b9f1-container.json

+{"uuid": "0bfde6fe-5198-49ef-858d-06e8d32e2863", "befores": [{"name": "case_data", "status": "passed", "start": 1716272621855, "stop": 1716272621855}], "start": 1716272621855, "stop": 1716272621914}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/6882c554-13b2-41a2-92c7-d5a2969a8b0a-container.json

+{"uuid": "39ddefed-a017-4c0c-ac37-328430736872", "befores": [{"name": "method", "status": "passed", "start": 1716272598828, "stop": 1716272598828}], "start": 1716272598828, "stop": 1716272598888}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/6884eebd-a67c-487e-97b8-3d848f96ebef-attachment.txt

+断言

InterfaceAutoTest/report/allure/json/698c6e34-e4b6-4aa1-9fa5-146a15d05f43-container.json

+{"uuid": "063e11d5-ef8f-4fe1-af6e-ff548f5fb6b0", "befores": [{"name": "case_data", "status": "passed", "start": 1716272633396, "stop": 1716272633396}], "start": 1716272633396, "stop": 1716272633537}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/69f78eb2-71c1-4f9e-9e66-67460b44554b-container.json

+{"uuid": "e8fe2978-1e40-414a-905b-763f199707ba", "befores": [{"name": "case_title", "status": "passed", "start": 1716272644816, "stop": 1716272644816}], "start": 1716272644816, "stop": 1716272644877}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/6a85f23a-41e9-4cbc-9eb3-c687b7000361-container.json

+{"uuid": "c5a95bdd-e796-4de1-a376-cd7d733475b9", "befores": [{"name": "url", "status": "passed", "start": 1716272599102, "stop": 1716272599102}], "start": 1716272599102, "stop": 1716272599206}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/6ac5eeb5-3b5a-470a-bdc0-663ff0bc7852-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803436442435584"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803445468577792"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803454528274432"}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/6af2e7b0-05b1-4d58-9281-6bf76903d875-container.json

+{"uuid": "e9c5314f-6edd-46ac-a492-19a21d1952be", "befores": [{"name": "case_level", "status": "passed", "start": 1716272644756, "stop": 1716272644756}], "start": 1716272644756, "stop": 1716272644812}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/6b0fbbb4-1e93-47b4-86df-4d0bdf904f0d-container.json

+{"uuid": "2ce74f30-2bfd-4bb1-bf0b-1bae3ae998af", "befores": [{"name": "url", "status": "passed", "start": 1716272598747, "stop": 1716272598747}], "start": 1716272598747, "stop": 1716272598823}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/6b2284c2-d707-4521-a5f1-3348d3480d00-container.json

+{"uuid": "8b5f4d40-12b8-4847-a620-980f05dc4087", "befores": [{"name": "method", "status": "passed", "start": 1716272621920, "stop": 1716272621920}], "start": 1716272621920, "stop": 1716272621982}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/6b396291-3ab3-4bb5-986a-e26be1d8125b-container.json

+{"uuid": "1180f47f-03b7-431c-83bb-f52e115d93c4", "befores": [{"name": "module_name", "status": "passed", "start": 1716272647080, "stop": 1716272647080}], "start": 1716272647080, "stop": 1716272647184}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/6baafec5-d2e1-4d4b-8521-ada44c1336b1-container.json

+{"uuid": "f3ea9e89-0238-4b33-89ee-e63a25c30b65", "befores": [{"name": "case_title", "status": "passed", "start": 1716272610541, "stop": 1716272610541}], "start": 1716272610541, "stop": 1716272610736}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/6bd48fe5-7220-48fd-b61d-6a10222c159a-container.json

+{"uuid": "bcd19cfb-6f86-4edd-b048-d0d670e6a71d", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272649196, "stop": 1716272649196}], "start": 1716272649196, "stop": 1716272649336}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/6c52fe59-12c6-430f-89c1-e192e7b1c9d1-container.json

+{"uuid": "81edbe95-51af-4c30-9c40-208c6816c1bd", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272598998, "stop": 1716272598998}], "start": 1716272598998, "stop": 1716272599093}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/6cba1058-2ab4-4927-a10a-dbb08465802e-result.json

+{"name": "正向用例", "status": "passed", "attachments": [{"name": "log", "source": "0ed32c3a-71a9-464b-9d1c-89acbbf9a760-attachment.txt", "type": "text/plain"}, {"name": "stdout", "source": "6884eebd-a67c-487e-97b8-3d848f96ebef-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'组织管理'"}, {"name": "api_name", "value": "'组织加入用户'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'高'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/org/v1/orgUsers/addUsersForOrg'"}, {"name": "mime", "value": "'query'"}, {"name": "case_data", "value": "{'orgCode': 'test_add_org', 'accounts': 'admin'}"}, {"name": "expect_data", "value": "{'state': True, 'message': '加入成功', 'value': ''}"}, {"name": "sql_data", "value": "None"}, {"name": "sql_type", "value": "None"}, {"name": "update_key", "value": "None"}], "start": 1716272621795, "stop": 1716272621848, "uuid": "777d31fa-9e70-42f8-88ba-22c7c65a88c7", "historyId": "385bda31fe152e15cd1fc6b7817225aa", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "组织管理"}, {"name": "story", "value": "组织加入用户"}, {"name": "severity", "value": "高"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/6d305ffa-2ebd-4a5c-9504-1032e03a01f4-container.json

+{"uuid": "e6c0878e-3bf4-4375-86dc-520b2f4a38b1", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272619383, "stop": 1716272619383}], "start": 1716272619383, "stop": 1716272619574}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/6e00ffdd-a975-4728-9736-a4da66ef26bc-container.json

+{"uuid": "bbc02eb7-05fa-4e18-b3d0-a7095151eb20", "befores": [{"name": "api_name", "status": "passed", "start": 1716272598893, "stop": 1716272598893}], "start": 1716272598893, "stop": 1716272598993}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/6f130541-5ab5-4551-b086-b3c4b7dbf7e6-container.json

+{"uuid": "4a97f53c-6bb1-4a83-a4ea-06b775525ff7", "befores": [{"name": "url", "status": "passed", "start": 1716272598828, "stop": 1716272598828}], "start": 1716272598828, "stop": 1716272598888}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/6f2a76e6-8123-4b77-8907-6ac9eb6e89ea-container.json

+{"uuid": "a5f44804-0097-4ae2-b8d1-3c0ef8d706dd", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272649196, "stop": 1716272649196}], "start": 1716272649196, "stop": 1716272649335}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/6f55f4ce-7a9f-4846-aeec-a31164b6d0da-container.json

+{"uuid": "434f825c-ce7e-4325-86be-1971c3338e3e", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272653522, "stop": 1716272653522}], "start": 1716272653522, "stop": 1716272653669}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/6f6229aa-decd-457b-b1dc-46895c33a446-container.json

+{"uuid": "55164136-cdab-451a-931d-b3a68f4eee2c", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272655685, "stop": 1716272655685}], "start": 1716272655685, "stop": 1716272655825}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/6f73f1b0-6540-4357-974a-dd709b822de0-container.json

+{"uuid": "c680498f-c375-45f1-ad7a-a4090b8acb45", "befores": [{"name": "case_title", "status": "passed", "start": 1716272614966, "stop": 1716272614966}], "start": 1716272614966, "stop": 1716272615157}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/6f76128c-da78-4c2f-b852-3f64abce85bd-container.json

+{"uuid": "230f49ea-f5e1-4134-a020-3dd07d980e6f", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272637955, "stop": 1716272637956}], "start": 1716272637955, "stop": 1716272638146}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/6f85529e-ff8a-4189-950e-38230a13cf65-container.json

+{"uuid": "52e11053-fab6-4b4d-bb80-50f335050008", "befores": [{"name": "update_key", "status": "passed", "start": 1716272624098, "stop": 1716272624098}], "start": 1716272624098, "stop": 1716272624193}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/6f8c0498-9e35-4c29-a343-3555344f132a-container.json

+{"uuid": "ef393156-4ca5-4d34-96b9-65edd0520e0c", "befores": [{"name": "mime", "status": "passed", "start": 1716272628365, "stop": 1716272628365}], "start": 1716272628365, "stop": 1716272628511}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/70ff664e-2f8f-49c1-966b-3d8b5f3df1e7-container.json

+{"uuid": "faf1462c-a2dc-4edf-9802-2749e39187bc", "befores": [{"name": "case_data", "status": "passed", "start": 1716272651357, "stop": 1716272651357}], "start": 1716272651357, "stop": 1716272651501}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/712a888c-0398-4911-b18d-7d7100b7f556-container.json

+{"uuid": "87e61d6d-7d53-446c-8d16-2f5ec5da2356", "befores": [{"name": "case_title", "status": "passed", "start": 1716272619383, "stop": 1716272619383}], "start": 1716272619383, "stop": 1716272619577}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/718d4378-f5cf-41ea-af1a-e386db07194e-container.json

+{"uuid": "dbcb8b50-7e43-42d6-a66c-4db1ebf6f970", "befores": [{"name": "module_name", "status": "passed", "start": 1716272598997, "stop": 1716272598997}], "start": 1716272598997, "stop": 1716272599099}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/71abcd7c-2aab-4327-b977-a77a6384a364-container.json

+{"uuid": "442584cb-8258-4108-b262-a0f1494c648e", "befores": [{"name": "case_title", "status": "passed", "start": 1716272604094, "stop": 1716272604094}], "start": 1716272604094, "stop": 1716272604156}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/71fb6c23-6002-4863-9e57-caa2135b7613-container.json

+{"uuid": "915b1e40-9473-4bab-96e8-6c0977b786d9", "befores": [{"name": "mime", "status": "passed", "start": 1716272619383, "stop": 1716272619383}], "start": 1716272619383, "stop": 1716272619576}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/7269fc9f-87c7-4db8-bacb-c474e8620dc5-container.json

+{"uuid": "af499a0a-c8af-4e30-a629-d1ecd9c7dbee", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272644817, "stop": 1716272644817}], "start": 1716272644817, "stop": 1716272644874}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/7298d070-f4af-436f-990d-432d9f1728d1-container.json

+{"uuid": "6fb2a2be-0138-4c54-8358-8b96276b98b1", "befores": [{"name": "mime", "status": "passed", "start": 1716272608243, "stop": 1716272608243}], "start": 1716272608243, "stop": 1716272608304}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/72ce433b-da83-42ff-a805-6643215d14bb-container.json

+{"uuid": "a5eba656-4867-42e9-b946-ab43199a1909", "befores": [{"name": "url", "status": "passed", "start": 1716272626206, "stop": 1716272626206}], "start": 1716272626206, "stop": 1716272626351}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/737f84c1-7370-41ba-a6bd-28e2d18af09e-container.json

+{"uuid": "24e46087-f153-468a-88b8-16374e55bbec", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272610542, "stop": 1716272610542}], "start": 1716272610542, "stop": 1716272610733}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/740a6018-cc60-40f5-9d7b-4bf834a6ca8d-container.json

+{"uuid": "be9bc24b-0acd-46c6-8e43-dcfd9bef9c35", "befores": [{"name": "update_key", "status": "passed", "start": 1716272649196, "stop": 1716272649196}], "start": 1716272649196, "stop": 1716272649334}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/746024dd-9120-4ccb-a70d-932a7b100145-container.json

+{"uuid": "eef6df20-b6e5-4cd1-b243-2d2f641a8fb6", "befores": [{"name": "case_level", "status": "passed", "start": 1716272647081, "stop": 1716272647081}], "start": 1716272647081, "stop": 1716272647183}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/754790a2-6f3c-4de7-9d89-eb87c1ca228b-container.json

+{"uuid": "edb01ef1-87ce-4b79-94a2-ba18f5355b20", "befores": [{"name": "update_key", "status": "passed", "start": 1716272633397, "stop": 1716272633397}], "start": 1716272633397, "stop": 1716272633536}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/75b6b178-6309-4a44-ae5c-0761ee4194cf-container.json

+{"uuid": "5cd32568-6c17-46d3-8994-a70baf9197dc", "befores": [{"name": "case_data", "status": "passed", "start": 1716272637955, "stop": 1716272637955}], "start": 1716272637955, "stop": 1716272638147}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/761db999-c5e2-43eb-9ef1-cc133e2f1377-container.json

+{"uuid": "2b5753b9-5a1b-4504-b8df-d70b58e28d62", "befores": [{"name": "case_level", "status": "passed", "start": 1716272598747, "stop": 1716272598747}], "start": 1716272598747, "stop": 1716272598824}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/76a447e9-df0c-4a5e-9495-e7cab8704f03-container.json

+{"uuid": "227e9154-fe3c-421b-b94b-47a652afb756", "befores": [{"name": "case_level", "status": "passed", "start": 1716272630525, "stop": 1716272630525}], "start": 1716272630525, "stop": 1716272630670}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/76cb374f-acab-4726-b9aa-2a71d34cda4f-attachment.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'username': 'admin', 'password': 'MTIzNDU2'}, 期望数据为:{'username': '超级管理员', 'loginStatus': True, 'account': 'admin'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTg5OTcsImlhdCI6MTcxNjI3MjU5N30.sY4lvg3FdRhPw7aTY0jx3ZeN03MQbTx1bARhQIZP2H41KaUr83P2Q4MTt-AKuPxQxYsVlEOH9rPkM0X7HhxEJA","username":"超级管理员","account":"admin","userId":"1","expiration":86400,"loginStatus":true,"userAttrs":{"tenantId":"-1"}}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/77c8cce4-1476-4ba3-8c61-238559a6cf28-container.json

+{"uuid": "26469d65-54bd-4500-b94c-b4ecb462d9be", "befores": [{"name": "module_name", "status": "passed", "start": 1716272599314, "stop": 1716272599314}], "start": 1716272599314, "stop": 1716272599413}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/77fa56e6-bb80-408c-b1d3-b7e2efac3e47-container.json

+{"uuid": "f7fed399-0df7-45b9-b542-eea5d72cf9fe", "befores": [{"name": "api_name", "status": "passed", "start": 1716272635751, "stop": 1716272635751}], "start": 1716272635751, "stop": 1716272635940}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/78191ea3-a1a6-4283-93dd-f289c015ed90-container.json

+{"uuid": "7d9c67f8-e08b-466c-a6c1-15034b6614f8", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272653522, "stop": 1716272653522}], "start": 1716272653522, "stop": 1716272653669}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/78a71d2c-1701-4286-b2be-c2564dd1194e-container.json

+{"uuid": "b2fba8ce-9a42-4932-bb7d-063cc02fb954", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272637955, "stop": 1716272637955}], "start": 1716272637955, "stop": 1716272638147}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/78f99964-29ab-40aa-ab44-c4fcf719660a-container.json

+{"uuid": "559d2457-8c82-436d-bb72-0d4ea6f490c9", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272617174, "stop": 1716272617174}], "start": 1716272617174, "stop": 1716272617362}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/7913ad36-b9cd-4366-80a1-12524ce769be-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803436442435584"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803445468577792"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803454528274432"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803463587971072"}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/7a0e3c01-d80a-45b6-9398-0a5a4e9b3562-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功", "trace": "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "6ac5eeb5-3b5a-470a-bdc0-663ff0bc7852-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'维度管理'"}, {"name": "api_name", "value": "'根据维度编码删除维度'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'DELETE'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'"}, {"name": "mime", "value": "'query'"}, {"name": "case_data", "value": "{'ids': '1792803379156631552'}"}, {"name": "expect_data", "value": "{'message': '删除维度成功'}"}, {"name": "sql_data", "value": "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"}, {"name": "sql_type", "value": "'select'"}, {"name": "update_key", "value": "'ids'"}], "start": 1716272628366, "stop": 1716272628501, "uuid": "b4b9152f-73b8-4913-9126-db6371e9884e", "historyId": "347d2f73ed73495ba7ba72dbf723f253", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "维度管理"}, {"name": "story", "value": "根据维度编码删除维度"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/7a418710-1031-4d98-bad3-10e95ae7c716-container.json

+{"uuid": "df65ef9e-f7e7-43a3-9d7c-8d6f2ae0ad0d", "befores": [{"name": "case_data", "status": "passed", "start": 1716272608243, "stop": 1716272608243}], "start": 1716272608243, "stop": 1716272608304}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/7a5b5f43-6de3-48ba-8e0b-a19a85d1b752-container.json

+{"uuid": "6913f9de-1ef0-4e22-a6c5-431a7dd044d6", "befores": [{"name": "method", "status": "passed", "start": 1716272606163, "stop": 1716272606163}], "start": 1716272606163, "stop": 1716272606225}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/7ab9cfab-b15e-4a7b-a6f4-4b43fcfd3951-container.json

+{"uuid": "e305cbbf-d6ca-4c32-b7ef-15c0caff8ce2", "befores": [{"name": "url", "status": "passed", "start": 1716272624098, "stop": 1716272624098}], "start": 1716272624098, "stop": 1716272624194}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/7acf54b7-ddb8-4a05-b26a-eafbbc2915c5-container.json

+{"uuid": "2519b66b-f9a4-45b7-a90c-7b2fed37fda0", "befores": [{"name": "case_title", "status": "passed", "start": 1716272606163, "stop": 1716272606163}], "start": 1716272606163, "stop": 1716272606226}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/7ad00186-5bd5-4c12-9c56-a760c50110ba-container.json

+{"uuid": "e3c2a1f5-19ac-46ca-95f2-22085f666eb9", "befores": [{"name": "mime", "status": "passed", "start": 1716272598747, "stop": 1716272598747}], "start": 1716272598747, "stop": 1716272598823}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/7b0e3f70-56b1-4228-8d61-3c73f3c32b36-container.json

+{"uuid": "3f3039e3-b119-4345-b93e-8ee359939914", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272653522, "stop": 1716272653522}], "start": 1716272653522, "stop": 1716272653669}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/7b4c2dcb-7a56-4900-853d-28a718d862dc-container.json

+{"uuid": "fc6059c9-119a-424a-aed0-fc7afe37e461", "befores": [{"name": "mime", "status": "passed", "start": 1716272644557, "stop": 1716272644557}], "start": 1716272644557, "stop": 1716272644749}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/7b8fbef1-31ee-43f8-8dcb-4be34a09d431-container.json

+{"uuid": "40bb4d65-0a49-4594-bd95-30b28511bf0b", "befores": [{"name": "method", "status": "passed", "start": 1716272649196, "stop": 1716272649196}], "start": 1716272649196, "stop": 1716272649337}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/7cf03f86-eab8-4904-ad23-e2dc368b41f6-container.json

+{"uuid": "b20b3a64-ca59-41c7-ac88-2996ed736574", "befores": [{"name": "case_title", "status": "passed", "start": 1716272644882, "stop": 1716272644882}], "start": 1716272644882, "stop": 1716272644953}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/7cfa9b18-033c-4110-86d5-61e3716f380f-container.json

+{"uuid": "ad6b849c-d237-4c9f-84bb-bf0873d77a59", "befores": [{"name": "module_name", "status": "passed", "start": 1716272614966, "stop": 1716272614966}], "start": 1716272614966, "stop": 1716272615157}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/7cfe40ca-7037-4206-abd6-7b4ce0d0a680-container.json

+{"uuid": "6fbaaf90-7f63-4131-9590-4f5311107280", "befores": [{"name": "method", "status": "passed", "start": 1716272644756, "stop": 1716272644756}], "start": 1716272644756, "stop": 1716272644812}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/7d44d66b-3854-458e-ae75-669bbae2e493-container.json

+{"uuid": "aa8a0114-759b-4654-80bf-6690f7e16dcf", "befores": [{"name": "case_title", "status": "passed", "start": 1716272621920, "stop": 1716272621920}], "start": 1716272621920, "stop": 1716272621983}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/7d618bff-a956-4698-a9f5-56b6f04ce16d-container.json

+{"uuid": "9c4afe48-ce64-4a8c-be10-da3799297299", "befores": [{"name": "method", "status": "passed", "start": 1716272651357, "stop": 1716272651357}], "start": 1716272651357, "stop": 1716272651502}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/7e718e31-a6c8-4b70-86af-10e136fa85a8-container.json

+{"uuid": "8e993414-e390-4730-952f-a6961decefc0", "befores": [{"name": "method", "status": "passed", "start": 1716272628365, "stop": 1716272628365}], "start": 1716272628365, "stop": 1716272628512}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/7ec7b859-bf88-4416-872b-96ebbf6d2cd3-container.json

+{"uuid": "c6bed11c-a3f3-4acf-a02f-0d909ac45c55", "befores": [{"name": "method", "status": "passed", "start": 1716272635751, "stop": 1716272635751}], "start": 1716272635751, "stop": 1716272635938}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/7fcd1bb5-7486-48fd-bc7e-fcdc2870bb33-container.json

+{"uuid": "83063096-35e6-471e-964b-b4ca56afa4b6", "befores": [{"name": "url", "status": "passed", "start": 1716272649196, "stop": 1716272649196}], "start": 1716272649196, "stop": 1716272649337}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/8047f95d-351d-4a7a-8b9e-f46491a4a819-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803532844318720"}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/8091b3ac-4368-4409-9783-c4ddc0fee42c-container.json

+{"uuid": "4e84d084-fc0c-4a79-af71-dafffa54883a", "befores": [{"name": "case_level", "status": "passed", "start": 1716272617174, "stop": 1716272617174}], "start": 1716272617172, "stop": 1716272617364}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/809bbc02-2470-40d4-95ad-8cabb86f4572-container.json

+{"uuid": "bcf0fda5-8ef7-49b2-bbd7-cf755f896a00", "befores": [{"name": "method", "status": "passed", "start": 1716272647081, "stop": 1716272647081}], "start": 1716272647081, "stop": 1716272647182}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/80d9c1ba-ec6f-44f3-88ff-fd4e3a95efde-container.json

+{"uuid": "8344fd6f-e507-4bcd-8071-8a5baf73d0a1", "befores": [{"name": "api_name", "status": "passed", "start": 1716272644816, "stop": 1716272644816}], "start": 1716272644816, "stop": 1716272644879}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/80fcd608-c35e-456d-8355-7f36b7f562f5-container.json

+{"uuid": "3176db72-fad5-4430-a9e4-4971cab85243", "befores": [{"name": "mime", "status": "passed", "start": 1716272598828, "stop": 1716272598828}], "start": 1716272598828, "stop": 1716272598888}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/81512013-7fc3-4aa7-9c6d-af06e66591b3-container.json

+{"uuid": "ede11eb1-294f-4a08-a9ca-61db51f3c2f7", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272599755, "stop": 1716272599755}], "start": 1716272599755, "stop": 1716272600007}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/81affeb0-7780-4afb-90a7-d34b6f133f3f-container.json

+{"uuid": "4cef4824-a3a8-4b3c-87f4-76f122019eef", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272599418, "stop": 1716272599418}], "start": 1716272599418, "stop": 1716272599518}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/81ea1162-5ba3-40d7-b2e9-503ade2712dc-container.json

+{"uuid": "6ae2b227-c7a7-43b7-98d0-0d4450fc718a", "befores": [{"name": "mime", "status": "passed", "start": 1716272621794, "stop": 1716272621794}], "start": 1716272621794, "stop": 1716272621850}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/81fcd8b3-5c8a-4e25-b117-5aa92c25a68d-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '刷新token成功' == None\n +  where None = <built-in method get of dict object at 0x0000014F19157380>('message')\n +    where <built-in method get of dict object at 0x0000014F19157380> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwNn0.W_ynWuu-79lzZS5ScuftmKzI8_B3z3llQ0gnSpahTsvIdUBKeaos4loXKk4DrzU4CGbchLTa5lK48yzcFXXQoA', 'userAttrs': {}, ...}.get\n +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwNn0.W_ynWuu-79lzZS5ScuftmKzI8_B3z3llQ0gnSpahTsvIdUBKeaos4loXKk4DrzU4CGbchLTa5lK48yzcFXXQoA', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\n +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json", "trace": "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '刷新token成功' == None\nE                +  where None = <built-in method get of dict object at 0x0000014F19157380>('message')\nE                +    where <built-in method get of dict object at 0x0000014F19157380> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwNn0.W_ynWuu-79lzZS5ScuftmKzI8_B3z3llQ0gnSpahTsvIdUBKeaos4loXKk4DrzU4CGbchLTa5lK48yzcFXXQoA', 'userAttrs': {}, ...}.get\nE                +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwNn0.W_ynWuu-79lzZS5ScuftmKzI8_B3z3llQ0gnSpahTsvIdUBKeaos4loXKk4DrzU4CGbchLTa5lK48yzcFXXQoA', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\nE                +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "1c641071-d8b1-4df1-87d7-8ac3fad1dbd6-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'认证接口'"}, {"name": "api_name", "value": "'刷新token'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'GET'"}, {"name": "url", "value": "'http://120.46.172.186:8080/refresh'"}, {"name": "mime", "value": "None"}, {"name": "case_data", "value": "None"}, {"name": "expect_data", "value": "{'message': '刷新token成功'}"}, {"name": "sql_data", "value": "None"}, {"name": "sql_type", "value": "None"}, {"name": "update_key", "value": "None"}], "start": 1716272608243, "stop": 1716272608294, "uuid": "a7d96320-6ab1-4b55-970b-ff86b059ac87", "historyId": "1dcae5f805bddffd6ce19e14c8b3458b", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "认证接口"}, {"name": "story", "value": "刷新token"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/82a420fd-7747-4741-8d38-c26567195595-container.json

+{"uuid": "0f8f71da-f487-4f7e-a02e-6dc83f9b6988", "befores": [{"name": "method", "status": "passed", "start": 1716272610325, "stop": 1716272610325}], "start": 1716272610325, "stop": 1716272610393}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/82c34c05-2763-4656-81a1-0a18915f24d4-container.json

+{"uuid": "33f5bef3-a7d9-49a1-a035-abab359f9c46", "befores": [{"name": "case_data", "status": "passed", "start": 1716272621599, "stop": 1716272621599}], "start": 1716272621599, "stop": 1716272621788}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/8418038c-b0b6-45c9-8a3d-1199c89e9324-container.json

+{"uuid": "4a0749f6-b039-415c-85a6-e315c9cf446a", "befores": [{"name": "url", "status": "passed", "start": 1716272621920, "stop": 1716272621920}], "start": 1716272621920, "stop": 1716272621982}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/84754921-78d4-4792-a3ca-6530195a77aa-container.json

+{"uuid": "f51b9aba-2190-4da3-b51c-cb41389bfa8b", "befores": [{"name": "case_level", "status": "passed", "start": 1716272610397, "stop": 1716272610397}], "start": 1716272610397, "stop": 1716272610536}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/84b819e3-e54d-4991-aec8-d91b4facea43-container.json

+{"uuid": "f702e8d6-8dac-4a6c-98f9-f0cee5fb4e5a", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272642365, "stop": 1716272642365}], "start": 1716272642365, "stop": 1716272642549}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/85400818-43be-4e24-bdb2-e22867d7d30b-container.json

+{"uuid": "53a472fc-a674-4c09-9937-10d01ee6b016", "befores": [{"name": "method", "status": "passed", "start": 1716272621794, "stop": 1716272621794}], "start": 1716272621794, "stop": 1716272621850}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/85ae93f8-01c3-439d-8df4-e30721a8fa5a-container.json

+{"uuid": "473bc97a-309d-4944-870c-9de8bbf53881", "befores": [{"name": "case_data", "status": "passed", "start": 1716272644817, "stop": 1716272644817}], "start": 1716272644817, "stop": 1716272644875}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/85ceacba-a9a7-4906-906e-ed90a5461aeb-container.json

+{"uuid": "a08aea46-9aa5-4b27-98ae-4af0d053ca9e", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272606163, "stop": 1716272606163}], "start": 1716272606163, "stop": 1716272606224}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/863bf4c4-7c7d-4928-a5b0-673bb135fb87-container.json

+{"uuid": "d603743e-1d6e-4bb2-9103-a198afc3daa3", "befores": [{"name": "case_level", "status": "passed", "start": 1716272610325, "stop": 1716272610325}], "start": 1716272610325, "stop": 1716272610393}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/865ce8c2-3f0f-443d-bc25-4707af444887-container.json

+{"uuid": "cf6f8089-5d9e-465a-a7e6-e6a56199083b", "befores": [{"name": "case_title", "status": "passed", "start": 1716272637955, "stop": 1716272637955}], "start": 1716272637955, "stop": 1716272638149}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/86b0c5ca-e201-41eb-a5e8-07ea4361d756-container.json

+{"uuid": "c637b839-0174-455b-8541-6c11d47812d0", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272599212, "stop": 1716272599212}], "start": 1716272599212, "stop": 1716272599309}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/86f15e0a-37c1-4a75-b3af-1c6eea37c60e-container.json

+{"uuid": "248fe819-e881-42cd-a55d-ce31bafa132d", "befores": [{"name": "method", "status": "passed", "start": 1716272621855, "stop": 1716272621855}], "start": 1716272621855, "stop": 1716272621915}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/87ec7796-1302-4503-b006-d2f418464d40-container.json

+{"uuid": "e6b8fae7-dc4a-4ce8-bb59-8d899b6dbf37", "befores": [{"name": "update_key", "status": "passed", "start": 1716272630526, "stop": 1716272630526}], "start": 1716272630526, "stop": 1716272630667}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/87f4a710-0424-44b8-aeb0-ecb97f8b5f42-container.json

+{"uuid": "e7bb0cb7-41aa-48c4-9c2f-b46b17164059", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272599212, "stop": 1716272599212}], "start": 1716272599212, "stop": 1716272599307}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/88837a20-7cc9-4b91-9596-ba2544f98d26-container.json

+{"uuid": "51f5ec3d-359a-4e68-b3f5-596b68524ad9", "befores": [{"name": "api_name", "status": "passed", "start": 1716272621986, "stop": 1716272621986}], "start": 1716272621986, "stop": 1716272622090}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/88c2414f-b104-47c8-bd5a-ecc67a847638-container.json

+{"uuid": "bd6cdc29-fba4-4745-80f3-f438ab96f07a", "befores": [{"name": "api_name", "status": "passed", "start": 1716272598828, "stop": 1716272598828}], "start": 1716272598828, "stop": 1716272598889}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/88f5f1fa-fbe5-4fb0-9b54-45945f616c32-container.json

+{"uuid": "c95dd28a-a230-435a-8c51-8dfbef5d9f2e", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272614968, "stop": 1716272614968}], "start": 1716272614968, "stop": 1716272615154}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/894e9971-5b7e-4087-a39f-12df89ac769a-container.json

+{"uuid": "23e8df7d-c852-4971-bd4c-4955d136098f", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272599755, "stop": 1716272599755}], "start": 1716272599755, "stop": 1716272600007}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/89e49ad1-5170-4b9a-99dc-bd277d54b2f7-container.json

+{"uuid": "24101ad2-f3e4-4715-94d5-cb96eed28b68", "befores": [{"name": "case_level", "status": "passed", "start": 1716272644882, "stop": 1716272644882}], "start": 1716272644882, "stop": 1716272644952}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/8a5bd089-d0fd-449e-81fb-5469bed943ce-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功", "trace": "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "8047f95d-351d-4a7a-8b9e-f46491a4a819-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'维度管理'"}, {"name": "api_name", "value": "'根据维度编码删除维度'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'DELETE'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'"}, {"name": "mime", "value": "'query'"}, {"name": "case_data", "value": "{'ids': '1792803475629817856'}"}, {"name": "expect_data", "value": "{'message': '删除维度成功'}"}, {"name": "sql_data", "value": "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"}, {"name": "sql_type", "value": "'select'"}, {"name": "update_key", "value": "'ids'"}], "start": 1716272647081, "stop": 1716272647173, "uuid": "45af3120-fde3-4ed9-942c-cf7d621b2682", "historyId": "f0f670cbfec7a9680aec241c756307a6", "testCaseId": "8c3ca9784f7a20f46f527b41c7204e5a", "fullName": "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "维度管理"}, {"name": "story", "value": "根据维度编码删除维度"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-老张"}, {"name": "parentSuite", "value": "test_case.test_mirZhang"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_mirZhang.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/8aba2ec8-409b-4165-9664-b2fdcf357b63-container.json

+{"uuid": "47816e5f-764d-42fe-bb52-2efff0a9b197", "befores": [{"name": "case_level", "status": "passed", "start": 1716272628365, "stop": 1716272628365}], "start": 1716272628365, "stop": 1716272628512}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/8adfea43-519a-4c4d-90b7-d681b34e129b-container.json

+{"uuid": "8b291b1e-acf7-46c6-ba32-f31d55c2e3bf", "befores": [{"name": "mime", "status": "passed", "start": 1716272599754, "stop": 1716272599754}], "start": 1716272599754, "stop": 1716272600008}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/8b3bbb7b-7ba8-462b-ba88-d505057f6bae-container.json

+{"uuid": "912df5a5-cdf2-4d24-98ff-98dc568c2ae2", "befores": [{"name": "method", "status": "passed", "start": 1716272653520, "stop": 1716272653520}], "start": 1716272653520, "stop": 1716272653671}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/8c15a03c-58cb-4ed1-be96-53622fcd467a-container.json

+{"uuid": "6db0633c-ffa3-43f3-9f31-ec39eca07118", "befores": [{"name": "api_name", "status": "passed", "start": 1716272653520, "stop": 1716272653520}], "start": 1716272653520, "stop": 1716272653674}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/8c9009fe-8048-4763-a6a4-b7ec0f96af22-container.json

+{"uuid": "f26d7291-11bc-43d9-ae37-77c32482091f", "befores": [{"name": "mime", "status": "passed", "start": 1716272599639, "stop": 1716272599639}], "start": 1716272599639, "stop": 1716272599739}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/8ce83d32-e17a-4625-a552-8b3678207ed2-container.json

+{"uuid": "561d357a-de11-4412-8792-53646e055758", "befores": [{"name": "mime", "status": "passed", "start": 1716272614966, "stop": 1716272614966}], "start": 1716272614966, "stop": 1716272615156}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/8d67a0e0-ae0b-4127-a271-540be3a1319e-container.json

+{"uuid": "c678ffab-0c3c-4270-9344-fee8962de8dd", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272599418, "stop": 1716272599418}], "start": 1716272599418, "stop": 1716272599519}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/8d99c607-9d5a-4283-8c7a-fe1c40630dd5-container.json

+{"uuid": "6c072958-361a-4942-9faa-78f58534ac0b", "befores": [{"name": "case_title", "status": "passed", "start": 1716272644958, "stop": 1716272644958}], "start": 1716272644958, "stop": 1716272645065}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/8ddab84a-025d-4cac-83c6-c59fadb364cb-container.json

+{"uuid": "0d3cb81f-4464-4bfe-b6c8-083c3a397c1d", "befores": [{"name": "url", "status": "passed", "start": 1716272655685, "stop": 1716272655685}], "start": 1716272655685, "stop": 1716272655836}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/8df46cef-d6ee-48b1-bc80-22aae00941a4-container.json

+{"uuid": "42349147-8fd1-449d-93c9-171f6e2bd7f0", "befores": [{"name": "case_title", "status": "passed", "start": 1716272651357, "stop": 1716272651357}], "start": 1716272651357, "stop": 1716272651503}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/8e03642c-41bb-4dc7-8eb1-7530797444fb-container.json

+{"uuid": "01aa6c82-8f63-4993-a558-f030feace7bd", "befores": [{"name": "mime", "status": "passed", "start": 1716272640166, "stop": 1716272640166}], "start": 1716272640166, "stop": 1716272640350}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/8e05e616-0e1c-4aec-b807-5702a5717db6-container.json

+{"uuid": "b90a6c45-9558-4361-966c-b45813924f4b", "befores": [{"name": "url", "status": "passed", "start": 1716272621986, "stop": 1716272621986}], "start": 1716272621986, "stop": 1716272622088}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/8e12ca92-7165-40cc-b4c0-55cc52ec8061-result.json

+{"name": "反向用例-密码正确,用户名过短", "status": "passed", "attachments": [{"name": "log", "source": "bc27cb32-c3e4-458d-b4c4-9ba7f5053749-attachment.txt", "type": "text/plain"}, {"name": "stdout", "source": "b02f83e9-08b2-49f4-897d-5035b2fd60eb-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'认证接口'"}, {"name": "api_name", "value": "'登录系统'"}, {"name": "case_title", "value": "'反向用例-密码正确,用户名过短'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/auth'"}, {"name": "mime", "value": "'application/json'"}, {"name": "case_data", "value": "{'username': 'a', 'password': 'MTIzNDU2'}"}, {"name": "expect_data", "value": "{'message': '账号或密码错误'}"}, {"name": "sql_data", "value": "None"}, {"name": "sql_type", "value": "None"}, {"name": "update_key", "value": "None"}], "start": 1716272599418, "stop": 1716272599517, "uuid": "1724f79b-d0fd-4a26-9d86-b2ceaa7088b2", "historyId": "1a3971dd942170d7f7bcf2c1f2eecd8f", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "认证接口"}, {"name": "story", "value": "登录系统"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/8e1b24e7-579e-433f-8935-02cd23e1fe10-container.json

+{"uuid": "7820a67a-65a5-4210-bfbf-231cc9a2b319", "befores": [{"name": "api_name", "status": "passed", "start": 1716272599527, "stop": 1716272599527}], "start": 1716272599527, "stop": 1716272599633}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/8e2a8484-506d-4224-a84a-0feec4cb08a2-container.json

+{"uuid": "608cae86-d548-4de7-a77e-70dc6e8be8aa", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272621987, "stop": 1716272621987}], "start": 1716272621987, "stop": 1716272622087}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/8e34b665-bc62-4f1e-b96b-2f9c2994e109-container.json

+{"uuid": "f4eb8564-bb90-4a72-b233-6165a61f30ee", "befores": [{"name": "case_level", "status": "passed", "start": 1716272621598, "stop": 1716272621598}], "start": 1716272621598, "stop": 1716272621789}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/8e57bd81-9cac-4e87-b7df-4c14fb9d34c4-container.json

+{"uuid": "6b109ab6-2eab-4ff0-a198-c52b22439a99", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272598998, "stop": 1716272598998}], "start": 1716272598998, "stop": 1716272599094}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/8e9fc669-3917-404c-b684-0902ba5e9cac-container.json

+{"uuid": "2a4449d8-af09-44c7-8ea8-21a97a4dc68b", "befores": [{"name": "case_data", "status": "passed", "start": 1716272599102, "stop": 1716272599102}], "start": 1716272599102, "stop": 1716272599206}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/8f225cf4-5730-498a-8781-55296b8a99cf-container.json

+{"uuid": "2d4fbb94-08f4-404a-86e1-046115786de5", "befores": [{"name": "api_name", "status": "passed", "start": 1716272626206, "stop": 1716272626206}], "start": 1716272626206, "stop": 1716272626352}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/8f6d2b23-fb33-43ed-8c0f-888baa7873c8-container.json

+{"uuid": "beeb3e79-b784-40a5-808a-be6da89f7b12", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272624098, "stop": 1716272624098}], "start": 1716272624098, "stop": 1716272624194}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/90791aae-8410-401b-9e45-8b2571f7b06b-container.json

+{"uuid": "2ac929cf-0d6a-41d8-9261-6554a1a93d36", "befores": [{"name": "case_data", "status": "passed", "start": 1716272655685, "stop": 1716272655685}], "start": 1716272655685, "stop": 1716272655835}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/908739da-782d-4aaf-8fe2-40961c286ce1-container.json

+{"uuid": "6c1ba28d-47f1-4268-bcfe-8c9a147ddc0d", "befores": [{"name": "case_level", "status": "passed", "start": 1716272598893, "stop": 1716272598893}], "start": 1716272598893, "stop": 1716272598992}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/90880793-cc86-428a-9204-901d5eb8a1a8-container.json

+{"uuid": "ad63c810-15ef-416a-bb4f-96783a8a78f8", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272633543, "stop": 1716272633543}], "start": 1716272633543, "stop": 1716272633729}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/9097ba7e-49c9-426f-a14b-100d7de6b218-container.json

+{"uuid": "de33ac9e-b9a6-4834-90f8-d7296ec9cb20", "befores": [{"name": "case_data", "status": "passed", "start": 1716272628365, "stop": 1716272628365}], "start": 1716272628365, "stop": 1716272628511}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/90c10715-79c0-4208-85cc-5141b5c92df5-container.json

+{"uuid": "fe35cec1-e69c-4101-8445-0f5b60a14932", "befores": [{"name": "update_key", "status": "passed", "start": 1716272610542, "stop": 1716272610542}], "start": 1716272610542, "stop": 1716272610732}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/9133d2ae-0dd4-47bf-9c34-f2aea812caac-container.json

+{"uuid": "48a22310-46a0-4e81-9553-5f559f52f364", "befores": [{"name": "api_name", "status": "passed", "start": 1716272651357, "stop": 1716272651357}], "start": 1716272651357, "stop": 1716272651503}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/91d7907c-e255-4493-98f9-72ed7b720ce3-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/93097442-258e-415d-bda0-de53e667e8ff-container.json

+{"uuid": "83a73288-205f-4b13-97cb-b8a7c87e0da2", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272612749, "stop": 1716272612749}], "start": 1716272612749, "stop": 1716272612939}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/9311b223-8b99-40b5-8d17-feb6b0714dcb-container.json

+{"uuid": "bda15e9f-cca8-47fa-a461-9b525c672c18", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272621599, "stop": 1716272621599}], "start": 1716272621599, "stop": 1716272621788}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/93844e49-aa38-48e8-a1ca-e64008279f91-container.json

+{"uuid": "d430e361-38f2-4cf2-98b8-33ed42a8a2e0", "befores": [{"name": "case_title", "status": "passed", "start": 1716272642364, "stop": 1716272642364}], "start": 1716272642364, "stop": 1716272642551}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/93f50988-0669-4a89-a2d3-c29305d4fc6b-container.json

+{"uuid": "b9b1ed66-1b22-4058-be1d-0b4a0fe15b8a", "befores": [{"name": "module_name", "status": "passed", "start": 1716272628365, "stop": 1716272628365}], "start": 1716272628365, "stop": 1716272628513}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/94355598-22a5-4562-9f3c-bcc68ccb5c7f-container.json

+{"uuid": "14599b8c-a6f1-476f-a18c-9a82ff36fd92", "befores": [{"name": "url", "status": "passed", "start": 1716272604094, "stop": 1716272604094}], "start": 1716272604094, "stop": 1716272604155}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/95c32b6b-cc4b-4fcd-a1c0-e6b4f3a05525-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '刷新token成功' == None\n +  where None = <built-in method get of dict object at 0x0000014F19124300>('message')\n +    where <built-in method get of dict object at 0x0000014F19124300> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjU5OH0.4JgpWuf9sSQnYV9dPIhf0I76OkCqUlLws0abjIB0nEM_iXrT2qd79jiUvk3kiwUvDIw9aHYQdvVjAFq8AQLNCw', 'userAttrs': {}, ...}.get\n +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjU5OH0.4JgpWuf9sSQnYV9dPIhf0I76OkCqUlLws0abjIB0nEM_iXrT2qd79jiUvk3kiwUvDIw9aHYQdvVjAFq8AQLNCw', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\n +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json", "trace": "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '刷新token成功' == None\nE                +  where None = <built-in method get of dict object at 0x0000014F19124300>('message')\nE                +    where <built-in method get of dict object at 0x0000014F19124300> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjU5OH0.4JgpWuf9sSQnYV9dPIhf0I76OkCqUlLws0abjIB0nEM_iXrT2qd79jiUvk3kiwUvDIw9aHYQdvVjAFq8AQLNCw', 'userAttrs': {}, ...}.get\nE                +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjU5OH0.4JgpWuf9sSQnYV9dPIhf0I76OkCqUlLws0abjIB0nEM_iXrT2qd79jiUvk3kiwUvDIw9aHYQdvVjAFq8AQLNCw', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\nE                +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "f6710333-f328-4e0d-922b-95e852462df9-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'认证接口'"}, {"name": "api_name", "value": "'刷新token'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'GET'"}, {"name": "url", "value": "'http://120.46.172.186:8080/refresh'"}, {"name": "mime", "value": "None"}, {"name": "case_data", "value": "None"}, {"name": "expect_data", "value": "{'message': '刷新token成功'}"}, {"name": "sql_data", "value": "None"}, {"name": "sql_type", "value": "None"}, {"name": "update_key", "value": "None"}], "start": 1716272599755, "stop": 1716272599845, "uuid": "b34ab8ef-a9f7-49f6-a2f8-0c36533f0b0b", "historyId": "1dcae5f805bddffd6ce19e14c8b3458b", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "认证接口"}, {"name": "story", "value": "刷新token"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/95c7bc0f-9ad2-4fc5-9dc1-2c14708d1057-container.json

+{"uuid": "7e8059fb-fc93-40ca-bb0d-221dd75d5ac1", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272599755, "stop": 1716272599755}], "start": 1716272599755, "stop": 1716272600007}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/962970b3-0775-4ced-a21b-a870fe108fa6-container.json

+{"uuid": "b943a483-d99a-4eb9-b999-39b086054d2a", "befores": [{"name": "url", "status": "passed", "start": 1716272610397, "stop": 1716272610397}], "start": 1716272610397, "stop": 1716272610536}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/96f526e6-37ba-4942-94dc-69ae81a96ff0-container.json

+{"uuid": "d109c2f2-94a3-4ac5-b911-4b647c61c2c9", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272610542, "stop": 1716272610542}], "start": 1716272610542, "stop": 1716272610734}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/970c03b7-4310-4d97-b53e-f2f66cf348e4-container.json

+{"uuid": "9cdf554d-5455-412a-a376-b098f8250453", "befores": [{"name": "api_name", "status": "passed", "start": 1716272602023, "stop": 1716272602023}], "start": 1716272602023, "stop": 1716272602084}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/9728dc76-e13c-4438-ba6b-d2cbd310f1e9-container.json

+{"uuid": "35cdd062-e490-45d1-bd5a-939ea82c7bac", "befores": [{"name": "method", "status": "passed", "start": 1716272644557, "stop": 1716272644557}], "start": 1716272644557, "stop": 1716272644750}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/97750afa-7b3e-46c8-8dc3-f16d69f0a2d5-container.json

+{"uuid": "4b07a220-4c64-4678-b5ed-b81a0b8f95c0", "befores": [{"name": "url", "status": "passed", "start": 1716272598997, "stop": 1716272598997}], "start": 1716272598997, "stop": 1716272599096}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/97a0788b-8a99-4a95-9e2e-121c0b3808c2-container.json

+{"uuid": "d767e6d2-6241-46e6-b207-dcea07133452", "befores": [{"name": "case_title", "status": "passed", "start": 1716272598747, "stop": 1716272598747}], "start": 1716272598747, "stop": 1716272598824}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/98810a61-6984-4f12-9afd-76fc29c79804-container.json

+{"uuid": "87d8fbcf-4af7-42b2-8732-acc6731e7488", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272621599, "stop": 1716272621599}], "start": 1716272621599, "stop": 1716272621787}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/989fadc2-4fae-48f9-b9ef-7d83678477f7-container.json

+{"uuid": "917a53b7-d568-47a9-ab66-d110efb44228", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272633396, "stop": 1716272633396}], "start": 1716272633396, "stop": 1716272633537}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/98a7496d-b008-463b-ab66-4e97741c0e82-container.json

+{"uuid": "ec396beb-e065-45de-8ce7-e8fd59aa9c88", "befores": [{"name": "method", "status": "passed", "start": 1716272599315, "stop": 1716272599315}], "start": 1716272599315, "stop": 1716272599412}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/98d0c83f-0934-43c2-8d4e-3a43d3e36ea8-container.json

+{"uuid": "03cb4f4b-ff60-4cd6-a725-0c89cc38aa73", "befores": [{"name": "url", "status": "passed", "start": 1716272644756, "stop": 1716272644756}], "start": 1716272644756, "stop": 1716272644812}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/996548f4-4f24-4577-a284-2e733270f498-container.json

+{"uuid": "d4a74fa2-6d18-43c6-9d02-e6badc85d332", "befores": [{"name": "case_title", "status": "passed", "start": 1716272612749, "stop": 1716272612749}], "start": 1716272612749, "stop": 1716272612951}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/99654b8d-abf8-451b-9cad-0f4d7d0decf3-container.json

+{"uuid": "497bf6aa-965c-49f6-b794-07e9ddd315df", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272598828, "stop": 1716272598828}], "start": 1716272598828, "stop": 1716272598887}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/9a734b52-1a49-4840-8426-6418ad7c2899-container.json

+{"uuid": "5b2057e8-6bd6-4e79-bea1-d8ade0f2b5c9", "befores": [{"name": "case_level", "status": "passed", "start": 1716272612749, "stop": 1716272612749}], "start": 1716272612749, "stop": 1716272612949}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/9b29920b-f532-4d2f-b372-d982f346094b-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/9b64c97e-6573-41d1-b497-2cfd169f8e86-container.json

+{"uuid": "8ce088ac-6efc-4f7d-b0a0-3cbe1442ebff", "befores": [{"name": "update_key", "status": "passed", "start": 1716272598998, "stop": 1716272598998}], "start": 1716272598998, "stop": 1716272599093}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/9b7bacfc-8daa-4d3f-a786-5832ba9f6390-container.json

+{"uuid": "e2c565c4-bb65-4c1c-9fc6-666acc26a01a", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272598748, "stop": 1716272598748}], "start": 1716272598748, "stop": 1716272598812}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/9b8be272-4726-4c52-bdc8-5ed3209805e2-container.json

+{"uuid": "ddacad00-d73a-4205-8600-2deab56b59a8", "befores": [{"name": "case_data", "status": "passed", "start": 1716272606163, "stop": 1716272606163}], "start": 1716272606163, "stop": 1716272606225}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/9be9793b-16a6-4508-9f42-f42dcb1b2aa5-container.json

+{"uuid": "6e91dabd-86a4-4279-a9fc-897bbac75167", "befores": [{"name": "api_name", "status": "passed", "start": 1716272619383, "stop": 1716272619383}], "start": 1716272619383, "stop": 1716272619577}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/9d992ded-6243-406d-b730-d516784b573c-result.json

+{"name": "test用例函数-依赖登录成功和添加维度成功", "status": "passed", "attachments": [{"name": "stdout", "source": "3f507870-023d-4574-bb9f-ac551fe2c56d-attachment.txt", "type": "text/plain"}], "start": 1716272633097, "stop": 1716272633098, "uuid": "c8330828-746b-4786-b66f-7407a84ed843", "historyId": "112831bd8b103ba5270ea46bde2822af", "testCaseId": "112831bd8b103ba5270ea46bde2822af", "fullName": "test_case.test_dependency.test_dependency#test1", "labels": [{"name": "story", "value": "test"}, {"name": "feature", "value": "test"}, {"name": "epic", "value": "BPM-场景测试"}, {"name": "tag", "value": "dependency(depends=['test_add_dem', 'test_login'])"}, {"name": "parentSuite", "value": "test_case.test_dependency"}, {"name": "suite", "value": "test_dependency"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_dependency.test_dependency"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/9e9976df-4a1e-4d5a-ad76-9db592a8540d-container.json

+{"uuid": "676e5ddf-33ab-43e0-adf4-0744366fb220", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272599315, "stop": 1716272599315}], "start": 1716272599315, "stop": 1716272599410}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/9ef009ab-165d-4697-ad0a-ad91bebf312e-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功", "trace": "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "06b7ab20-aa5d-489e-ae13-0a082a4ad043-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'组织管理'"}, {"name": "api_name", "value": "'添加组织'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'高'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/org/v1/org/addOrg'"}, {"name": "mime", "value": "'json'"}, {"name": "case_data", "value": "{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}"}, {"name": "expect_data", "value": "{'message': '添加组织成功'}"}, {"name": "sql_data", "value": "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}"}, {"name": "sql_type", "value": "'select|delete'"}, {"name": "update_key", "value": "'demId'"}], "start": 1716272635752, "stop": 1716272635930, "uuid": "8da1278d-2136-4d8f-b212-edbf7e6e7319", "historyId": "526f1fd519b78b4955668d6cfd277048", "testCaseId": "8c3ca9784f7a20f46f527b41c7204e5a", "fullName": "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "组织管理"}, {"name": "story", "value": "添加组织"}, {"name": "severity", "value": "高"}, {"name": "epic", "value": "BPM系统-老张"}, {"name": "parentSuite", "value": "test_case.test_mirZhang"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_mirZhang.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/9f647417-0a69-4c88-9236-0285e7e26976-container.json

+{"uuid": "b494d3d9-a780-4b0e-b765-96f52bc54ba6", "befores": [{"name": "case_data", "status": "passed", "start": 1716272630525, "stop": 1716272630525}], "start": 1716272630525, "stop": 1716272630669}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/a073bb59-38cd-436a-8967-b6b572a3e410-container.json

+{"uuid": "79f9d5e0-b0e9-4aac-b10e-6ad35edf6e69", "befores": [{"name": "mime", "status": "passed", "start": 1716272621986, "stop": 1716272621986}], "start": 1716272621986, "stop": 1716272622088}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/a0b906b1-b9d4-4565-8376-2d74e87d037c-container.json

+{"uuid": "0e414d24-84af-4a8b-a110-13e461a46d36", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272614968, "stop": 1716272614968}], "start": 1716272614968, "stop": 1716272615155}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/a0f9283c-5e2b-43ef-b363-c4cf75862ea9-container.json

+{"uuid": "acafeb99-bf97-4f64-bbf3-d1c2c1b035a7", "befores": [{"name": "update_key", "status": "passed", "start": 1716272626206, "stop": 1716272626206}], "start": 1716272626206, "stop": 1716272626348}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/a11edbcd-c80e-49f4-8ebb-02aeed5c957d-container.json

+{"uuid": "23f2ab88-d8f9-49e3-8e8d-78c8b20497da", "befores": [{"name": "case_level", "status": "passed", "start": 1716272653520, "stop": 1716272653520}], "start": 1716272653520, "stop": 1716272653672}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/a13c67e6-79e2-4d4e-bdc3-2b4770198b84-container.json

+{"uuid": "1348a45f-911c-4fda-bb13-84e80525b1e6", "befores": [{"name": "mime", "status": "passed", "start": 1716272602023, "stop": 1716272602023}], "start": 1716272602023, "stop": 1716272602082}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/a14527c0-fbde-42ba-864e-95175d514ade-container.json

+{"uuid": "e8ba7ce5-d640-4c82-aceb-9c3c3219bdec", "befores": [{"name": "module_name", "status": "passed", "start": 1716272610541, "stop": 1716272610541}], "start": 1716272610541, "stop": 1716272610736}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/a1ae0ec4-df3c-42eb-850e-739f4cd8db11-container.json

+{"uuid": "eb7edddf-d376-42f0-81c4-af96bf4bdda8", "befores": [{"name": "api_name", "status": "passed", "start": 1716272610397, "stop": 1716272610397}], "start": 1716272610397, "stop": 1716272610538}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/a1bdffe0-de80-4c3d-9b47-8a86f084491b-container.json

+{"uuid": "285d2d8a-a65e-4ef2-983c-438feb756ec8", "befores": [{"name": "update_key", "status": "passed", "start": 1716272599103, "stop": 1716272599103}], "start": 1716272599103, "stop": 1716272599204}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/a21c4cf1-3cd5-44f4-85d8-69f24a4ea36e-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/a2f757c3-14f0-423e-8e04-3783724b5847-container.json

+{"uuid": "8b962214-53e0-4b5f-84e3-a67b7e8d8ad9", "befores": [{"name": "case_title", "status": "passed", "start": 1716272621794, "stop": 1716272621794}], "start": 1716272621794, "stop": 1716272621851}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/a3f40216-d4b4-4a11-88ab-1c087cf9642a-container.json

+{"uuid": "1399b5db-0077-4415-a292-9ae44af739b0", "befores": [{"name": "update_key", "status": "passed", "start": 1716272635751, "stop": 1716272635751}], "start": 1716272635751, "stop": 1716272635936}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/a49f9d6a-cf97-44f9-aecb-b9cb352ea9f9-container.json

+{"uuid": "b119c779-325d-497a-82ca-9b61d752cf44", "befores": [{"name": "case_title", "status": "passed", "start": 1716272599754, "stop": 1716272599754}], "start": 1716272599754, "stop": 1716272600010}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/a5271aa2-844a-42a2-85d5-565df8dc09b8-result.json

+{"name": "反向用例-用户名正确,密码过短", "status": "passed", "attachments": [{"name": "log", "source": "64e2a74f-d693-4476-b5d6-d4aec697e75f-attachment.txt", "type": "text/plain"}, {"name": "stdout", "source": "fc9b3bae-d15e-4686-a396-4bc5a82f4a25-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'认证接口'"}, {"name": "api_name", "value": "'登录系统'"}, {"name": "case_title", "value": "'反向用例-用户名正确,密码过短'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/auth'"}, {"name": "mime", "value": "'application/json'"}, {"name": "case_data", "value": "{'username': 'admin', 'password': 'm'}"}, {"name": "expect_data", "value": "{'message': '账号或密码错误'}"}, {"name": "sql_data", "value": "None"}, {"name": "sql_type", "value": "None"}, {"name": "update_key", "value": "None"}], "start": 1716272598998, "stop": 1716272599093, "uuid": "d70bed7d-bd04-4f16-ac9b-5738ec3bc976", "historyId": "f5ad8b2871fbe9131e812a7e7fd4507e", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "认证接口"}, {"name": "story", "value": "登录系统"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/a5407b3e-268e-4f33-9180-93aa0d11c4ed-container.json

+{"uuid": "519c7689-7000-47ea-9e35-765a21ef19e0", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272621987, "stop": 1716272621987}], "start": 1716272621987, "stop": 1716272622088}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/a5a611d3-3de3-40ad-be2a-b94aaa2354a2-container.json

+{"uuid": "484df2ba-83f7-4659-9ada-17f018476c1a", "befores": [{"name": "api_name", "status": "passed", "start": 1716272649196, "stop": 1716272649196}], "start": 1716272649196, "stop": 1716272649339}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/a666564e-f8e5-4793-b279-86ac222886a8-container.json

+{"uuid": "c41d337f-3a76-4031-a782-f5f86b28eed4", "befores": [{"name": "api_name", "status": "passed", "start": 1716272621855, "stop": 1716272621855}], "start": 1716272621855, "stop": 1716272621917}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/a6f47cb4-d497-4552-9f6c-28c3f6f9d386-container.json

+{"uuid": "5961ba2c-1d58-4d4e-983e-bf4b5f3f64d0", "befores": [{"name": "update_key", "status": "passed", "start": 1716272647081, "stop": 1716272647081}], "start": 1716272647081, "stop": 1716272647179}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/a7a6849d-2693-4c73-b86d-1069b8e03a76-container.json

+{"uuid": "90869bc4-85ce-428b-9633-bae75355f495", "befores": [{"name": "case_level", "status": "passed", "start": 1716272637955, "stop": 1716272637955}], "start": 1716272637955, "stop": 1716272638149}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/a7b8bc7b-6d45-4121-b429-ae63efa4a6ae-container.json

+{"uuid": "0c22bb46-51bb-4f2e-9b64-103a63139077", "befores": [{"name": "case_level", "status": "passed", "start": 1716272635751, "stop": 1716272635751}], "start": 1716272635751, "stop": 1716272635940}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/a7be127e-1da7-465f-9baa-45cc69c689c6-container.json

+{"uuid": "76f72148-c808-4095-9ed7-d5a9eec7d1eb", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272621920, "stop": 1716272621920}], "start": 1716272621920, "stop": 1716272621980}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/a7c5d9b9-fe40-4e23-ba61-ed2c3c1d20b2-container.json

+{"uuid": "23ac2f75-06ea-4f5b-ba50-281e30a58949", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272608243, "stop": 1716272608243}], "start": 1716272608243, "stop": 1716272608303}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/a7f1cd56-a82e-4435-8a9d-6f3e4ec02fa9-container.json

+{"uuid": "10bca374-e9dd-445c-aa36-bdae2e6c0026", "befores": [{"name": "update_key", "status": "passed", "start": 1716272599755, "stop": 1716272599755}], "start": 1716272599755, "stop": 1716272600006}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/a7fe362c-1593-46d9-bc70-46ad15a5f74c-container.json

+{"uuid": "2ce24935-e578-4b9c-977a-5f7793f0c847", "befores": [{"name": "case_data", "status": "passed", "start": 1716272599639, "stop": 1716272599639}], "start": 1716272599639, "stop": 1716272599739}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/a7ff00f7-b961-4f8d-b859-546a43ca3b75-container.json

+{"uuid": "c1aaa079-ef5a-48dc-8a2f-f83ac183d7ef", "befores": [{"name": "module_name", "status": "passed", "start": 1716272612749, "stop": 1716272612749}], "start": 1716272612749, "stop": 1716272612951}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/a889f066-4691-4059-95af-b27d07608ecb-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功", "trace": "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "d09fd688-af1e-4321-8100-e93cccbae6bd-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'维度管理'"}, {"name": "api_name", "value": "'根据维度编码删除维度'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'DELETE'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'"}, {"name": "mime", "value": "'query'"}, {"name": "case_data", "value": "{'ids': '1792803475629817856'}"}, {"name": "expect_data", "value": "{'message': '删除维度成功'}"}, {"name": "sql_data", "value": "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"}, {"name": "sql_type", "value": "'select'"}, {"name": "update_key", "value": "'ids'"}], "start": 1716272653523, "stop": 1716272653661, "uuid": "5b558a67-19fb-42da-8fdc-d7f0cede5c83", "historyId": "f0f670cbfec7a9680aec241c756307a6", "testCaseId": "8c3ca9784f7a20f46f527b41c7204e5a", "fullName": "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "维度管理"}, {"name": "story", "value": "根据维度编码删除维度"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-老张"}, {"name": "parentSuite", "value": "test_case.test_mirZhang"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_mirZhang.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/a8af4800-eace-45de-8023-02f07caf9c49-result.json

+{"name": "反向用例-密码正确,用户名过长", "status": "passed", "attachments": [{"name": "log", "source": "4bee1565-ae76-4818-a667-087d24c27356-attachment.txt", "type": "text/plain"}, {"name": "stdout", "source": "c66d15bc-24e7-486d-ae88-8e801cb5bf6e-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'认证接口'"}, {"name": "api_name", "value": "'登录系统'"}, {"name": "case_title", "value": "'反向用例-密码正确,用户名过长'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/auth'"}, {"name": "mime", "value": "'json'"}, {"name": "case_data", "value": "{'username': 'adminadminadminadmin', 'password': 'MTIzNDU2'}"}, {"name": "expect_data", "value": "{'message': '账号或密码错误'}"}, {"name": "sql_data", "value": "None"}, {"name": "sql_type", "value": "None"}, {"name": "update_key", "value": "None"}], "start": 1716272599315, "stop": 1716272599407, "uuid": "9883f12e-5bed-46f3-90cb-4651c0b34b3d", "historyId": "968bf5f1bc5266807075e84dfd49d322", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "认证接口"}, {"name": "story", "value": "登录系统"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/a98cc813-91f8-4adf-8f10-d65b8cc70298-container.json

+{"uuid": "1d472972-fe17-4e5f-b75f-52c9fecb183c", "befores": [{"name": "update_key", "status": "passed", "start": 1716272621795, "stop": 1716272621795}], "start": 1716272621795, "stop": 1716272621848}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/a9a84ba2-31e0-42e5-b018-d57332c64698-container.json

+{"uuid": "c2de4163-c43e-4a0f-84c9-3e05b057882f", "befores": [{"name": "url", "status": "passed", "start": 1716272628365, "stop": 1716272628365}], "start": 1716272628365, "stop": 1716272628512}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/aa501e36-37a2-4c00-98c4-9612aed56c96-container.json

+{"uuid": "1605b0b6-7c26-4ec3-b327-e61fc9990ffa", "befores": [{"name": "mime", "status": "passed", "start": 1716272624098, "stop": 1716272624098}], "start": 1716272624098, "stop": 1716272624194}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/aa5b80d1-2bea-4ca0-88bd-2b78c6b13924-container.json

+{"uuid": "710bc5df-1505-4d69-81ef-03e750bc00ad", "befores": [{"name": "case_title", "status": "passed", "start": 1716272602023, "stop": 1716272602023}], "start": 1716272602023, "stop": 1716272602083}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/aa889633-7047-4f6a-85e4-e42cc017077d-container.json

+{"uuid": "4365b4c3-f831-4714-b98d-51140c3b755e", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272649196, "stop": 1716272649196}], "start": 1716272649196, "stop": 1716272649335}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/ab596775-848e-442c-b3ec-408251fefbc4-container.json

+{"uuid": "8fdb094f-cba2-4cff-bc48-a1301c75bee9", "befores": [{"name": "case_data", "status": "passed", "start": 1716272610541, "stop": 1716272610541}], "start": 1716272610541, "stop": 1716272610734}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/ab60fe1f-cfa4-4b70-8950-0d134199cc18-container.json

+{"uuid": "28991240-2e0d-4450-bebc-0d0dd8a83b79", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272599639, "stop": 1716272599639}], "start": 1716272599639, "stop": 1716272599738}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/ab98d777-6e12-4beb-aa93-383f59c9ad1f-container.json

+{"uuid": "01500b2c-5f66-4bce-9aa8-2625d833e47c", "befores": [{"name": "update_key", "status": "passed", "start": 1716272598828, "stop": 1716272598828}], "start": 1716272598828, "stop": 1716272598886}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/abef3a88-7b03-4784-b507-4ea0927e1da0-container.json

+{"uuid": "5d2fc7a8-a503-434c-839c-e9944a8ec5b9", "befores": [{"name": "case_level", "status": "passed", "start": 1716272655684, "stop": 1716272655684}], "start": 1716272655684, "stop": 1716272655837}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/abf84792-f2ec-441a-a2b2-2d91eac46968-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTg5OTgsImlhdCI6MTcxNjI3MjU5OH0.4JgpWuf9sSQnYV9dPIhf0I76OkCqUlLws0abjIB0nEM_iXrT2qd79jiUvk3kiwUvDIw9aHYQdvVjAFq8AQLNCw","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDAsImlhdCI6MTcxNjI3MjYwMH0.atAGdmkk-bhC9iAhggDWp0VlgVLl39hN3_u2ytWqmjm1GWT-vhDYRgCax56GrBuR6EkPJEseXgX-S8EfzoWXhg","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDIsImlhdCI6MTcxNjI3MjYwMn0.2ULfoTRcxys6pnuEKjHxZH4GI20D2qBisJFYoBn2GdZLw23Xapl1u2ATzI1w5cFlBcJf3_bFyVN7eo7OfOOMUg","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDQsImlhdCI6MTcxNjI3MjYwNH0.TOXPdeAD96XQ_Maa-ITQDDQZTnKhlW09esTDC6-C8_Wux9HSk3bWURoOvhmcidK-lCj4Tvw1ZO0dYFWGR8-lsg","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDYsImlhdCI6MTcxNjI3MjYwNn0.W_ynWuu-79lzZS5ScuftmKzI8_B3z3llQ0gnSpahTsvIdUBKeaos4loXKk4DrzU4CGbchLTa5lK48yzcFXXQoA","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDgsImlhdCI6MTcxNjI3MjYwOH0.LsIqI6NBfMYmLfeFQHaiE3TLchmrNO9P3P92GkiuQQoiDTEXfelTGerbpaF-Qp4K4_45jG2cACLNB8dNwS0m-w","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/ac1f744e-2b3c-4739-917c-d0a37c04d258-container.json

+{"uuid": "38b9b125-8481-45b6-ac32-8a296603a74c", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272647081, "stop": 1716272647081}], "start": 1716272647081, "stop": 1716272647180}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/acbb7452-1fe4-4be5-8a04-44bd8d69c63d-container.json

+{"uuid": "36c58433-7f92-42aa-8ec9-92d637ab5d05", "befores": [{"name": "case_level", "status": "passed", "start": 1716272649196, "stop": 1716272649196}], "start": 1716272649196, "stop": 1716272649338}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/acc562d7-a093-46c1-9dc5-2f042f6a56a1-result.json

+{"name": "反向用例-用户名正确,密码过长", "status": "passed", "attachments": [{"name": "log", "source": "bec89abd-6bbb-4eca-9fa4-0992902cd615-attachment.txt", "type": "text/plain"}, {"name": "stdout", "source": "f0d73289-0b63-4cb1-b728-7302fc1acc55-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'认证接口'"}, {"name": "api_name", "value": "'登录系统'"}, {"name": "case_title", "value": "'反向用例-用户名正确,密码过长'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/auth'"}, {"name": "mime", "value": "'application/json'"}, {"name": "case_data", "value": "{'username': 'admin', 'password': 'MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2'}"}, {"name": "expect_data", "value": "{'message': '账号或密码错误'}"}, {"name": "sql_data", "value": "None"}, {"name": "sql_type", "value": "None"}, {"name": "update_key", "value": "None"}], "start": 1716272598895, "stop": 1716272598989, "uuid": "946a5629-c66f-4fd5-8b98-9bb29349f299", "historyId": "37bde76add67e3f73e804e1ff293bbd9", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "认证接口"}, {"name": "story", "value": "登录系统"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/ad15fe1e-15a4-438a-b68d-bdc13eed56a4-container.json

+{"uuid": "38c2d4d9-4642-486e-ad73-3ab89d47c9e9", "befores": [{"name": "api_name", "status": "passed", "start": 1716272598747, "stop": 1716272598747}], "start": 1716272598747, "stop": 1716272598824}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/ad357bb3-2813-449f-b589-747b8c249901-result.json

+{"name": "正向用例", "status": "passed", "attachments": [{"name": "log", "source": "0be0f8ba-cd5d-45f6-9c86-b79a73be7457-attachment.txt", "type": "text/plain"}, {"name": "stdout", "source": "dbda4c3f-ae3e-4116-a81a-6b27471e5e73-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'组织管理'"}, {"name": "api_name", "value": "'删除组织'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'高'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/org/v1/org/deleteOrg'"}, {"name": "mime", "value": "'text/plain'"}, {"name": "case_data", "value": "'test_add_org'"}, {"name": "expect_data", "value": "{'state': True, 'message': '删除组织成功！', 'value': ''}"}, {"name": "sql_data", "value": "None"}, {"name": "sql_type", "value": "None"}, {"name": "update_key", "value": "None"}], "start": 1716272644883, "stop": 1716272644938, "uuid": "897bff55-0c89-4809-984e-7d23734dfe86", "historyId": "5ee7a985530eff8db65cbc3fbd8fd151", "testCaseId": "8c3ca9784f7a20f46f527b41c7204e5a", "fullName": "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "组织管理"}, {"name": "story", "value": "删除组织"}, {"name": "severity", "value": "高"}, {"name": "epic", "value": "BPM系统-老张"}, {"name": "parentSuite", "value": "test_case.test_mirZhang"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_mirZhang.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/ad7c4525-baf7-4626-8240-a17baa56ddfd-container.json

+{"uuid": "4b51e555-c8d8-4308-9b53-8dafa827e16b", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272621920, "stop": 1716272621920}], "start": 1716272621920, "stop": 1716272621979}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/ae045fec-3885-43d6-a64b-813ece40e216-container.json

+{"uuid": "1c9b3c3d-7370-45b5-b1a9-c26303870947", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272612749, "stop": 1716272612749}], "start": 1716272612749, "stop": 1716272612938}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/ae159987-41f0-4a11-8956-233831fcf803-attachment.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'query': {'orgCode': 'test_add_org'}, 'body': [{'alias': 'sz', 'value': 100}, {'alias': 'kc', 'value': '语文课'}]}, 期望数据为:{'state': True, 'message': '保存组织参数成功！', 'value': ''}, 服务器返回的数据为：{"state":true,"message":"保存组织参数成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/aed18a77-b651-49bc-a592-7546e0b65e8c-container.json

+{"uuid": "78586e9a-43ba-43b1-82c8-dac6021f1247", "befores": [{"name": "module_name", "status": "passed", "start": 1716272633396, "stop": 1716272633396}], "start": 1716272633396, "stop": 1716272633540}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/af1754bf-74ca-4a36-afd2-fc297d1aafba-container.json

+{"uuid": "5de4d0cd-a479-4176-872b-a7f2f91b20f8", "befores": [{"name": "update_key", "status": "passed", "start": 1716272602024, "stop": 1716272602024}], "start": 1716272602024, "stop": 1716272602080}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/af1ef3f5-3c38-467f-9867-9b52fe600cc6-container.json

+{"uuid": "92b4d7ca-f522-43b6-9d65-8466e917bc31", "befores": [{"name": "mime", "status": "passed", "start": 1716272644817, "stop": 1716272644817}], "start": 1716272644817, "stop": 1716272644876}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/afbcc11f-b96c-4c6d-8b29-3d59731eac1d-container.json

+{"uuid": "017f1b9f-b257-4e20-9a4a-7b84e1a3e497", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272599315, "stop": 1716272599315}], "start": 1716272599315, "stop": 1716272599410}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/b029a5c7-d878-46d3-ab3e-2e96c73e2af5-container.json

+{"uuid": "3a254b55-5b66-446d-a50c-6ab8b31d264a", "befores": [{"name": "mime", "status": "passed", "start": 1716272642365, "stop": 1716272642365}], "start": 1716272642365, "stop": 1716272642550}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/b02f83e9-08b2-49f4-897d-5035b2fd60eb-attachment.txt

+断言

InterfaceAutoTest/report/allure/json/b0a85f82-e1f5-4929-8f6a-17e673c6ffaa-container.json

+{"uuid": "e5e2219e-8d4a-4632-89e2-eb3d00926a0c", "befores": [{"name": "api_name", "status": "passed", "start": 1716272598997, "stop": 1716272598997}], "start": 1716272598997, "stop": 1716272599098}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/b0af8578-d5bb-43a4-bc0c-45b9db288d2b-container.json

+{"uuid": "4b9d95c9-6cfd-4235-a459-f54b0cbaf7b6", "befores": [{"name": "method", "status": "passed", "start": 1716272644958, "stop": 1716272644958}], "start": 1716272644958, "stop": 1716272645064}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/b0da7df5-574e-467a-971b-48508c0f922d-container.json

+{"uuid": "51ab051c-41d1-48a8-952d-bd4b2eb1008f", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272621856, "stop": 1716272621856}], "start": 1716272621856, "stop": 1716272621912}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/b122a896-87da-4a28-90e5-622ddb0e9e94-container.json

+{"uuid": "aa6d2f54-7123-4370-8091-bca9657e5c13", "befores": [{"name": "case_title", "status": "passed", "start": 1716272598893, "stop": 1716272598893}], "start": 1716272598893, "stop": 1716272598993}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/b1249f2c-b9d9-43b0-9cbf-5508cb91d8d7-container.json

+{"uuid": "a43829e6-393e-4301-a4ba-ffa4c4301c78", "befores": [{"name": "case_title", "status": "passed", "start": 1716272635751, "stop": 1716272635751}], "start": 1716272635751, "stop": 1716272635940}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/b1dcb8af-0503-40fc-addc-95dbd31061fc-attachment.txt

+断言

InterfaceAutoTest/report/allure/json/b2004d28-4ed8-43fc-aa1b-4142f447ec26-container.json

+{"uuid": "c3d1bfd2-61ad-428d-8ed5-08381ad03275", "befores": [{"name": "case_data", "status": "passed", "start": 1716272621987, "stop": 1716272621987}], "start": 1716272621987, "stop": 1716272622088}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/b3161c0a-66d7-4e9b-ab7a-7370a38dcaee-container.json

+{"uuid": "1aa741f8-bfe2-4e58-8b10-760afa79a99a", "befores": [{"name": "method", "status": "passed", "start": 1716272640166, "stop": 1716272640166}], "start": 1716272640166, "stop": 1716272640350}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/b425891b-2550-4075-8040-864c1d9f28f9-container.json

+{"uuid": "c6f67c47-20d2-47e4-8d49-2372a79bf8db", "befores": [{"name": "api_name", "status": "passed", "start": 1716272647080, "stop": 1716272647080}], "start": 1716272647080, "stop": 1716272647183}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/b45f6213-be95-4a3b-92ce-581d95b7cb4f-container.json

+{"uuid": "172eb29e-b87a-4692-9494-adf27c0a3554", "befores": [{"name": "case_title", "status": "passed", "start": 1716272628365, "stop": 1716272628365}], "start": 1716272628365, "stop": 1716272628513}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/b53f0eab-69b6-4a7a-aef9-3d0d7fdf1fdd-container.json

+{"uuid": "3f9ce304-58e9-4235-8d31-32df3bd00eb7", "befores": [{"name": "module_name", "status": "passed", "start": 1716272599754, "stop": 1716272599754}], "start": 1716272599754, "stop": 1716272600010}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/b59f3d30-7af7-4dad-b457-6e9ecdf236fe-container.json

+{"uuid": "1aa0154e-9b30-4db9-a8a6-cd24c37ae85a", "befores": [{"name": "url", "status": "passed", "start": 1716272599527, "stop": 1716272599527}], "start": 1716272599527, "stop": 1716272599632}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/b6de6734-1f6e-488c-9e70-426ef5c637c3-container.json

+{"uuid": "5e487e36-d24b-4e22-83f7-b9647f86f6e8", "befores": [{"name": "api_name", "status": "passed", "start": 1716272632685, "stop": 1716272632685}], "start": 1716272632685, "stop": 1716272632840}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/b716e2ce-2885-44af-85d4-25d837cd98a3-container.json

+{"uuid": "912cf656-4db1-427d-93a4-91a98960d7fe", "befores": [{"name": "mime", "status": "passed", "start": 1716272599212, "stop": 1716272599212}], "start": 1716272599212, "stop": 1716272599309}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/b7b0f933-ffe8-4e8b-b66f-a1693f1d1559-container.json

+{"uuid": "c09f654c-efa4-4b9b-a905-98b01bc25961", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272647081, "stop": 1716272647081}], "start": 1716272647081, "stop": 1716272647180}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/b7b78afa-ae51-4f4d-98c8-8bf36d2e0b3e-container.json

+{"uuid": "4706c2e8-8103-4e96-8b80-646d2a2d73ff", "befores": [{"name": "url", "status": "passed", "start": 1716272599212, "stop": 1716272599212}], "start": 1716272599212, "stop": 1716272599310}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/b7bc57f9-4125-4dc0-932a-2725ec7d5208-container.json

+{"uuid": "ad68f5bf-b3dd-4846-bc03-5a3564a41920", "befores": [{"name": "case_level", "status": "passed", "start": 1716272598828, "stop": 1716272598828}], "start": 1716272598828, "stop": 1716272598889}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/b7d58a8b-f5c1-4e45-a556-28f83e1ef530-container.json

+{"uuid": "2a4a140b-b5d0-4ec2-bdf0-72e5e7618664", "befores": [{"name": "case_data", "status": "passed", "start": 1716272599418, "stop": 1716272599418}], "start": 1716272599418, "stop": 1716272599520}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/b826e0c1-c536-4afe-a8d1-59301bd73fef-container.json

+{"uuid": "37fdf4e5-bdd2-4832-9fd2-2da7936bc3b9", "befores": [{"name": "update_key", "status": "passed", "start": 1716272621987, "stop": 1716272621987}], "start": 1716272621987, "stop": 1716272622086}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/b8419b7a-abb7-4191-8966-fb43f086596d-attachment.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为test_add_org, 期望数据为:{'state': True, 'message': '删除组织成功！', 'value': ''}, 服务器返回的数据为：{"state":true,"message":"删除组织成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/b842cbb8-2c0b-428c-8a8b-00be676606ed-container.json

+{"uuid": "f1a136d3-e716-4202-946a-600fc7f03450", "befores": [{"name": "url", "status": "passed", "start": 1716272610325, "stop": 1716272610325}], "start": 1716272610325, "stop": 1716272610392}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/b8790a9e-f531-4d30-984d-251477cac0a8-container.json

+{"uuid": "4aa2f166-d781-4eae-beeb-ff29323ff16e", "befores": [{"name": "method", "status": "passed", "start": 1716272617174, "stop": 1716272617174}], "start": 1716272617174, "stop": 1716272617364}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/b943c04e-ddaf-4a4e-8234-0376013b7378-container.json

+{"uuid": "3f93f768-1bb3-4bbf-8a1f-749c8c88d71e", "befores": [{"name": "case_title", "status": "passed", "start": 1716272653520, "stop": 1716272653520}], "start": 1716272653520, "stop": 1716272653673}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/b9611f2e-8f96-488a-b0c7-45b61f85497f-container.json

+{"uuid": "faeb0818-8f97-4937-a485-6ef0afec3a6f", "befores": [{"name": "module_name", "status": "passed", "start": 1716272598893, "stop": 1716272598893}], "start": 1716272598893, "stop": 1716272598993}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/b9644a89-7642-4c3f-9199-c5668e7e517f-container.json

+{"uuid": "44f5f624-8694-4935-b63b-b347a83bbda3", "befores": [{"name": "mime", "status": "passed", "start": 1716272633543, "stop": 1716272633543}], "start": 1716272633543, "stop": 1716272633730}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/ba5ced4e-afad-4807-9d2a-e532c100695c-container.json

+{"uuid": "bf70cb5a-5a1c-4fb4-a33f-21001816a485", "befores": [{"name": "module_name", "status": "passed", "start": 1716272644816, "stop": 1716272644816}], "start": 1716272644816, "stop": 1716272644879}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/bace4401-0a28-4f4e-89ae-ab81bcebf370-container.json

+{"uuid": "4cb67617-0d70-4616-a5b3-06116727301c", "befores": [{"name": "mime", "status": "passed", "start": 1716272655685, "stop": 1716272655685}], "start": 1716272655685, "stop": 1716272655836}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/bb65795d-ddf2-405f-bc81-2b08b2638f3e-container.json

+{"uuid": "969a68cd-9c91-454e-9173-ee000003c5ed", "befores": [{"name": "update_key", "status": "passed", "start": 1716272599639, "stop": 1716272599639}], "start": 1716272599639, "stop": 1716272599738}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/bb8fcfd5-d306-4cea-bcaa-0b19f316458f-container.json

+{"uuid": "be9dfa4f-c71e-4ffc-82db-14710daa749b", "befores": [{"name": "case_level", "status": "passed", "start": 1716272599527, "stop": 1716272599527}], "start": 1716272599527, "stop": 1716272599632}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/bbe49fd2-cfff-4358-85a4-a27ca3dd0a32-container.json

+{"uuid": "0295edc7-5053-4778-8480-58ffdaad9f24", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272598748, "stop": 1716272598748}], "start": 1716272598748, "stop": 1716272598812}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/bc27cb32-c3e4-458d-b4c4-9ba7f5053749-attachment.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'username': 'a', 'password': 'MTIzNDU2'}, 期望数据为:{'message': '账号或密码错误'}, 服务器返回的数据为：{"state":false,"message":"账号或密码错误","logId":"1792803332960567296"}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/bc3acc63-8a54-424f-81a9-90333648739d-attachment.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'query': {'orgCode': 'test_add_org'}, 'body': [{'alias': 'sz', 'value': 100}, {'alias': 'kc', 'value': '语文课'}]}, 期望数据为:{'state': True, 'message': '保存组织参数成功！', 'value': ''}, 服务器返回的数据为：{"state":true,"message":"保存组织参数成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/bcafc22b-9246-4e99-a0d2-d20130bc8b86-container.json

+{"uuid": "59eb740d-a9e5-476e-a4bf-d4d1e58705f8", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272640167, "stop": 1716272640167}], "start": 1716272640167, "stop": 1716272640349}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/bcc2e3b2-a522-4515-87b3-73e3ac8c7b3d-attachment.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'username': '☯㍿卍卐', 'password': 'MTIzNDU2'}, 期望数据为:{'message': '账号或密码错误'}, 服务器返回的数据为：{"state":false,"message":"账号或密码错误","logId":"1792803333417746432"}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/bcc78257-b741-4361-9859-beb465d0886e-container.json

+{"uuid": "ffbc9f60-dbcf-4c4a-9edf-f4826805c87f", "befores": [{"name": "mime", "status": "passed", "start": 1716272599418, "stop": 1716272599418}], "start": 1716272599418, "stop": 1716272599520}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/bdaf3eb2-b0aa-40e7-8718-a3bdda508496-container.json

+{"uuid": "1c131b73-96c3-4e39-9811-c3838d718412", "befores": [{"name": "case_data", "status": "passed", "start": 1716272599212, "stop": 1716272599212}], "start": 1716272599212, "stop": 1716272599309}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/bdc85633-14ca-463c-8895-2fa14238880f-container.json

+{"uuid": "5d4c021b-9e49-4ed3-9452-4354c1c36d31", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272617174, "stop": 1716272617174}], "start": 1716272617174, "stop": 1716272617363}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/bec89abd-6bbb-4eca-9fa4-0992902cd615-attachment.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'username': 'admin', 'password': 'MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2'}, 期望数据为:{'message': '账号或密码错误'}, 服务器返回的数据为：{"state":false,"message":"账号或密码错误","logId":"1792803330750169088"}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/bf4e1790-2ddc-4ad4-978d-e583b9bf2b72-container.json

+{"uuid": "dd51f2d8-c0e9-4c6b-9cf3-afcd5da0f572", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272642365, "stop": 1716272642365}], "start": 1716272642365, "stop": 1716272642549}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/c0c614d5-fa8f-487a-999e-17ec8f520a60-container.json

+{"uuid": "56e1deaa-05bb-49cd-a642-ef49bfb0dae4", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272619383, "stop": 1716272619383}], "start": 1716272619383, "stop": 1716272619574}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/c0e0b25e-e47f-4ed7-80c7-4066eac114da-container.json

+{"uuid": "7fa53bed-02d3-40bb-94d7-a77fa3a1a9d1", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272644883, "stop": 1716272644883}], "start": 1716272644883, "stop": 1716272644949}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/c1785414-f483-4cc8-a514-c776f27603f7-container.json

+{"uuid": "82c27095-f872-44fa-a3d7-8dcb64a1d173", "befores": [{"name": "url", "status": "passed", "start": 1716272621794, "stop": 1716272621794}], "start": 1716272621794, "stop": 1716272621850}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/c1c03bbb-c2bf-4c43-bae2-525538b94526-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '删除维度成功' == '删除维度成功！'\n  \n  - 删除维度成功！\n  ?       -\n  + 删除维度成功", "trace": "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == '删除维度成功！'\nE                 \nE                 - 删除维度成功！\nE                 ?       -\nE                 + 删除维度成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "e78097d6-f262-4f12-9f73-2ac425814e91-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'维度管理'"}, {"name": "api_name", "value": "'根据维度编码删除维度'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'DELETE'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'"}, {"name": "mime", "value": "'query'"}, {"name": "case_data", "value": "{'ids': '需要更新'}"}, {"name": "expect_data", "value": "{'message': '删除维度成功'}"}, {"name": "sql_data", "value": "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"}, {"name": "sql_type", "value": "'select'"}, {"name": "update_key", "value": "'ids'"}], "start": 1716272621987, "stop": 1716272622080, "uuid": "28266b7a-99b9-4953-84e1-513ec1ec4e3f", "historyId": "347d2f73ed73495ba7ba72dbf723f253", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "维度管理"}, {"name": "story", "value": "根据维度编码删除维度"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/c1cf4cca-e680-4eab-b861-434f422380b5-container.json

+{"uuid": "86466924-07fe-456b-abe5-3278437aeb58", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272635751, "stop": 1716272635751}], "start": 1716272635751, "stop": 1716272635937}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/c2602f59-47a9-4a3d-bd6f-cbe6f555d3ef-container.json

+{"uuid": "6f33881b-3ba5-4818-99ba-7887252cc716", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272644756, "stop": 1716272644756}], "start": 1716272644756, "stop": 1716272644810}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/c2a1793f-245a-43ec-a4ef-7d21640d3af7-container.json

+{"uuid": "4b665d89-e011-44a9-8dd0-b6e0c2ce99bf", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272610397, "stop": 1716272610397}], "start": 1716272610397, "stop": 1716272610535}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/c36f8892-cdf9-4d78-a399-3aad03bba67e-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '刷新token成功' == None\n +  where None = <built-in method get of dict object at 0x0000014F191A66C0>('message')\n +    where <built-in method get of dict object at 0x0000014F191A66C0> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwMH0.atAGdmkk-bhC9iAhggDWp0VlgVLl39hN3_u2ytWqmjm1GWT-vhDYRgCax56GrBuR6EkPJEseXgX-S8EfzoWXhg', 'userAttrs': {}, ...}.get\n +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwMH0.atAGdmkk-bhC9iAhggDWp0VlgVLl39hN3_u2ytWqmjm1GWT-vhDYRgCax56GrBuR6EkPJEseXgX-S8EfzoWXhg', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\n +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json", "trace": "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F17992220>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '认证接口', api_name = '刷新token', case_title = '正向用例'\ncase_level = '中', method = 'GET', url = 'http://120.46.172.186:8080/refresh', mime = None, case_data = None\nexpect_data = {'message': '刷新token成功'}, sql_data = None, sql_type = None, update_key = None\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '刷新token成功' == None\nE                +  where None = <built-in method get of dict object at 0x0000014F191A66C0>('message')\nE                +    where <built-in method get of dict object at 0x0000014F191A66C0> = {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwMH0.atAGdmkk-bhC9iAhggDWp0VlgVLl39hN3_u2ytWqmjm1GWT-vhDYRgCax56GrBuR6EkPJEseXgX-S8EfzoWXhg', 'userAttrs': {}, ...}.get\nE                +      where {'account': '', 'loginStatus': True, 'token': 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOj...3MjYwMH0.atAGdmkk-bhC9iAhggDWp0VlgVLl39hN3_u2ytWqmjm1GWT-vhDYRgCax56GrBuR6EkPJEseXgX-S8EfzoWXhg', 'userAttrs': {}, ...} = <bound method Response.json of <Response [200]>>()\nE                +        where <bound method Response.json of <Response [200]>> = <Response [200]>.json\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "04d15195-6da2-42ea-8d54-c79fd8fef927-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'认证接口'"}, {"name": "api_name", "value": "'刷新token'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'GET'"}, {"name": "url", "value": "'http://120.46.172.186:8080/refresh'"}, {"name": "mime", "value": "None"}, {"name": "case_data", "value": "None"}, {"name": "expect_data", "value": "{'message': '刷新token成功'}"}, {"name": "sql_data", "value": "None"}, {"name": "sql_type", "value": "None"}, {"name": "update_key", "value": "None"}], "start": 1716272602024, "stop": 1716272602074, "uuid": "21b7eb43-6197-4901-b681-af5d31760ac2", "historyId": "1dcae5f805bddffd6ce19e14c8b3458b", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "认证接口"}, {"name": "story", "value": "刷新token"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/c48528ad-3715-46ca-9317-ade1235ab983-container.json

+{"uuid": "5868a3bf-bf37-42d8-8c8a-a36a87357032", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272633543, "stop": 1716272633543}], "start": 1716272633543, "stop": 1716272633729}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/c4f1be2d-07e0-4dd8-beb7-328f6d3d32f7-container.json

+{"uuid": "7de74905-5c37-4dd7-876f-c14063ccd5cf", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272626206, "stop": 1716272626206}], "start": 1716272626206, "stop": 1716272626350}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/c506e9cf-c35d-4151-bdea-63fda8ab1bbf-container.json

+{"uuid": "b3452116-edad-43bc-9944-da07e9086885", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272621599, "stop": 1716272621599}], "start": 1716272621599, "stop": 1716272621788}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/c5484219-0ebb-41c8-8a36-32da150026b2-container.json

+{"uuid": "b3c3cb24-ae52-4af3-abf9-defa2b468659", "befores": [{"name": "module_name", "status": "passed", "start": 1716272599639, "stop": 1716272599639}], "start": 1716272599639, "stop": 1716272599741}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/c555e677-f3d6-401b-a176-e1551e7f9383-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803436442435584"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803445468577792"}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/c633a858-d295-4619-b70a-33bf62ef5ac4-container.json

+{"uuid": "e2826847-610f-44d6-bd44-164d01239ed8", "befores": [{"name": "module_name", "status": "passed", "start": 1716272626205, "stop": 1716272626206}], "start": 1716272626205, "stop": 1716272626353}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/c66d15bc-24e7-486d-ae88-8e801cb5bf6e-attachment.txt

+断言

InterfaceAutoTest/report/allure/json/c76b71f1-72e8-4c61-b89a-9f691d8dbaa4-attachment.txt

+断言成功

InterfaceAutoTest/report/allure/json/c7e6c0b4-fe1e-4eba-9a82-36b5250f1d5f-container.json

+{"uuid": "68d1e34d-fa79-47f5-bd2b-6940516be03f", "befores": [{"name": "mime", "status": "passed", "start": 1716272599102, "stop": 1716272599102}], "start": 1716272599102, "stop": 1716272599206}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/c8038d2b-04c5-4264-9006-a49f29ce5415-container.json

+{"uuid": "57e0f106-9f43-4d7a-abec-7c75d4879b17", "befores": [{"name": "case_data", "status": "passed", "start": 1716272612749, "stop": 1716272612749}], "start": 1716272612749, "stop": 1716272612948}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/c9492951-20fe-4492-a71f-868ee29578f0-container.json

+{"uuid": "8232be02-1eb4-469e-9622-9809ff17c1ce", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272604095, "stop": 1716272604095}], "start": 1716272604095, "stop": 1716272604153}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/c99b2f82-8195-4e81-82af-519a34a0ea3a-container.json

+{"uuid": "b36cc034-7a0b-4f19-85e2-1c9dbd65eb4e", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272621795, "stop": 1716272621795}], "start": 1716272621795, "stop": 1716272621848}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/c9eae618-f036-47fc-b558-11e55e37943b-attachment.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'code': 'api_auto_test_add_dem', 'description': 'api_auto_test_add_dem', 'isDefault': 0, 'name': 'api_auto_test_add_dem'}, 期望数据为:{'message': '添加维度成功！'}, 服务器返回的数据为：{"state":true,"message":"添加维度成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/ca9bd544-c38f-4da6-b4a7-30690727f055-container.json

+{"uuid": "75d6f655-d27d-42c3-a936-82490f1e29b1", "befores": [{"name": "case_data", "status": "passed", "start": 1716272598997, "stop": 1716272598997}], "start": 1716272598997, "stop": 1716272599095}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/cac5048c-b670-4ca7-b653-6da11bd4d8c9-container.json

+{"uuid": "e2c7fd55-bad9-46c2-925a-1e7ae2a2b051", "befores": [{"name": "case_data", "status": "passed", "start": 1716272598893, "stop": 1716272598893}], "start": 1716272598893, "stop": 1716272598991}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/cae899c4-a817-4d40-a3e8-c036a997d1aa-container.json

+{"uuid": "260803bb-3ab1-41f1-bc1c-06ed2c395ec4", "befores": [{"name": "method", "status": "passed", "start": 1716272632685, "stop": 1716272632685}], "start": 1716272632685, "stop": 1716272632839}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/cbfacff6-42ae-48b4-acee-4331ee20b7c0-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功", "trace": "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "9b29920b-f532-4d2f-b372-d982f346094b-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'组织管理'"}, {"name": "api_name", "value": "'添加组织'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'高'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/org/v1/org/addOrg'"}, {"name": "mime", "value": "'json'"}, {"name": "case_data", "value": "{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}"}, {"name": "expect_data", "value": "{'message': '添加组织成功'}"}, {"name": "sql_data", "value": "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}"}, {"name": "sql_type", "value": "'select|delete'"}, {"name": "update_key", "value": "'demId'"}], "start": 1716272621599, "stop": 1716272621780, "uuid": "1dfe4690-98d0-4b43-ada0-749b2afe1376", "historyId": "487ae598a2b30a5ea2489bb3e5fa08a4", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "组织管理"}, {"name": "story", "value": "添加组织"}, {"name": "severity", "value": "高"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/cd64b664-dda4-4b1a-9c5c-de54d2a067cd-container.json

+{"uuid": "f673e798-8106-46a0-a6f7-2b4903334380", "befores": [{"name": "update_key", "status": "passed", "start": 1716272642365, "stop": 1716272642365}], "start": 1716272642365, "stop": 1716272642547}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/cda2b95a-2c39-48e7-9791-93893a144845-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '删除维度成功' == '删除维度成功！'\n  \n  - 删除维度成功！\n  ?       -\n  + 删除维度成功", "trace": "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == '删除维度成功！'\nE                 \nE                 - 删除维度成功！\nE                 ?       -\nE                 + 删除维度成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "a21c4cf1-3cd5-44f4-85d8-69f24a4ea36e-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'维度管理'"}, {"name": "api_name", "value": "'根据维度编码删除维度'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'DELETE'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'"}, {"name": "mime", "value": "'query'"}, {"name": "case_data", "value": "{'ids': '需要更新'}"}, {"name": "expect_data", "value": "{'message': '删除维度成功'}"}, {"name": "sql_data", "value": "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"}, {"name": "sql_type", "value": "'select'"}, {"name": "update_key", "value": "'ids'"}], "start": 1716272644958, "stop": 1716272645054, "uuid": "25f9cf42-df26-4ca4-b7b5-45802bfb99b1", "historyId": "f0f670cbfec7a9680aec241c756307a6", "testCaseId": "8c3ca9784f7a20f46f527b41c7204e5a", "fullName": "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "维度管理"}, {"name": "story", "value": "根据维度编码删除维度"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-老张"}, {"name": "parentSuite", "value": "test_case.test_mirZhang"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_mirZhang.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/cdf9b61a-3db3-4b6e-ac18-1865e9a30556-container.json

+{"uuid": "e292c057-1d58-406f-b082-e7b6c6e8c040", "befores": [{"name": "update_key", "status": "passed", "start": 1716272644958, "stop": 1716272644958}], "start": 1716272644958, "stop": 1716272645061}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/ce416a51-1177-41ee-b720-34210b593fe4-container.json

+{"uuid": "01e81227-4b5a-4d56-a4de-cd4c88eb2e5f", "befores": [{"name": "url", "status": "passed", "start": 1716272633396, "stop": 1716272633396}], "start": 1716272633396, "stop": 1716272633538}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/cf03fe52-71da-4048-a083-441091bb4112-container.json

+{"uuid": "759cab96-5da4-4dca-9985-e58347f771e7", "befores": [{"name": "mime", "status": "passed", "start": 1716272621855, "stop": 1716272621855}], "start": 1716272621855, "stop": 1716272621915}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/cf0a4853-8b64-4b38-a4a2-9d6579ec5d3b-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功", "trace": "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "270697f6-0292-4bff-95fc-8756213876bd-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'组织管理'"}, {"name": "api_name", "value": "'添加组织'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'高'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/org/v1/org/addOrg'"}, {"name": "mime", "value": "'json'"}, {"name": "case_data", "value": "{'code': 'test_add_org', 'demId': '需要更新', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}"}, {"name": "expect_data", "value": "{'message': '添加组织成功'}"}, {"name": "sql_data", "value": "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}"}, {"name": "sql_type", "value": "'select|delete'"}, {"name": "update_key", "value": "'demId'"}], "start": 1716272610542, "stop": 1716272610722, "uuid": "08a93c9f-5e8c-45f4-9231-1a9a3a67d652", "historyId": "487ae598a2b30a5ea2489bb3e5fa08a4", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "组织管理"}, {"name": "story", "value": "添加组织"}, {"name": "severity", "value": "高"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/cf1cc90e-2d10-416c-b31a-13636b25a852-container.json

+{"uuid": "6adc9d9d-6d40-4442-b251-26bd8de3f874", "befores": [{"name": "update_key", "status": "passed", "start": 1716272599315, "stop": 1716272599315}], "start": 1716272599315, "stop": 1716272599408}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/cf624b17-6936-4884-befe-a2d2d2b9c284-container.json

+{"uuid": "dfbd8b3d-63fd-4ba5-9c84-97a7e0cd914e", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272610397, "stop": 1716272610397}], "start": 1716272610397, "stop": 1716272610534}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/cfcc3d42-fa8d-4f29-820b-8cfd2383495d-container.json

+{"uuid": "ce3853c7-088a-42ac-9b46-2a429904bacd", "befores": [{"name": "mime", "status": "passed", "start": 1716272632685, "stop": 1716272632685}], "start": 1716272632685, "stop": 1716272632839}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/cfcfb378-0fc5-4b44-8bdf-7bc8f7e679b1-container.json

+{"uuid": "e585d573-2f6d-4d3d-a0f5-f613bebe9c5a", "befores": [{"name": "api_name", "status": "passed", "start": 1716272599754, "stop": 1716272599754}], "start": 1716272599754, "stop": 1716272600010}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/d09fd688-af1e-4321-8100-e93cccbae6bd-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803532844318720"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803541883043840"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803550955323392"}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803475629817856'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":false,"message":"","logId":"1792803560044380160"}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/d0e90b02-269c-49bf-9f16-4325cd20c1a0-container.json

+{"uuid": "53fe940d-ae52-48ae-80df-6af8d977e701", "befores": [{"name": "case_level", "status": "passed", "start": 1716272624097, "stop": 1716272624097}], "start": 1716272624097, "stop": 1716272624196}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/d0f3b779-e73a-48a3-a0ef-788faec5fd6d-attachment.txt

+断言成功

InterfaceAutoTest/report/allure/json/d250166b-a571-4007-b046-7c1b3134fdd3-container.json

+{"uuid": "b4025f08-90f6-44d0-af5d-dea86e252a60", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272598828, "stop": 1716272598828}], "start": 1716272598828, "stop": 1716272598887}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/d42d9f7e-a557-4a2c-8e2f-c7c6ae5d653b-container.json

+{"uuid": "5a964d5d-bba5-4cba-8137-dfec6de63dad", "befores": [{"name": "method", "status": "passed", "start": 1716272642364, "stop": 1716272642364}], "start": 1716272642364, "stop": 1716272642550}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/d46870c8-0a00-47ae-a7be-e66e87afd635-container.json

+{"uuid": "4b45b374-7739-4eab-a483-36f233045d0f", "befores": [{"name": "case_title", "status": "passed", "start": 1716272599212, "stop": 1716272599212}], "start": 1716272599212, "stop": 1716272599311}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/d46ff6a9-0dc0-446d-a0de-ad7db6c6ad9c-container.json

+{"uuid": "3ae8e690-cbd0-4885-b444-6aeb24d3dfb0", "befores": [{"name": "url", "status": "passed", "start": 1716272617174, "stop": 1716272617174}], "start": 1716272617174, "stop": 1716272617364}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/d4cfc3b7-e89e-49fa-8541-7668b03037fd-container.json

+{"uuid": "0006bf61-6aad-4a34-ad39-7078ceff6435", "befores": [{"name": "api_name", "status": "passed", "start": 1716272617172, "stop": 1716272617172}], "start": 1716272617172, "stop": 1716272617365}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/d5587eb1-c85a-45aa-8353-2cf95e7f87f8-container.json

+{"uuid": "ef1d2f7e-ed30-46c8-aeaa-16ef66892977", "befores": [{"name": "api_name", "status": "passed", "start": 1716272644882, "stop": 1716272644882}], "start": 1716272644882, "stop": 1716272644954}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/d57d0221-bb41-4a05-a42a-d73ebe8c98d1-container.json

+{"uuid": "d8572fdb-d140-44bc-9f16-9ab8046f5ec4", "befores": [{"name": "url", "status": "passed", "start": 1716272599418, "stop": 1716272599418}], "start": 1716272599418, "stop": 1716272599521}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/d5a1ff26-c92b-45c0-9008-2c2f7ff55360-container.json

+{"uuid": "4fd8b307-8dc1-49e9-9c14-118c8c677e58", "befores": [{"name": "mime", "status": "passed", "start": 1716272599315, "stop": 1716272599315}], "start": 1716272599315, "stop": 1716272599411}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/d5d54284-e22a-4585-a9df-e79eb76485d5-container.json

+{"uuid": "04e48809-c502-48e6-a380-56c3a697c9ee", "befores": [{"name": "case_title", "status": "passed", "start": 1716272640166, "stop": 1716272640166}], "start": 1716272640166, "stop": 1716272640352}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/d6be3f4f-e7ee-44ef-a9d6-f3ea8d714d60-container.json

+{"uuid": "17eba1a7-b6e7-47fa-8f73-2383643bd2b9", "befores": [{"name": "mime", "status": "passed", "start": 1716272599527, "stop": 1716272599527}], "start": 1716272599527, "stop": 1716272599631}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/d717c764-e61c-435d-8029-e935ee89ec44-container.json

+{"uuid": "33080d88-8497-4eb2-9487-ce35a236fce6", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272644883, "stop": 1716272644883}], "start": 1716272644883, "stop": 1716272644950}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/d732692c-b3f6-4d0e-94e5-29400c195ff7-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功", "trace": "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "674782b5-95dd-437b-bbed-deec053e265f-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'组织管理'"}, {"name": "api_name", "value": "'添加组织'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'高'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/org/v1/org/addOrg'"}, {"name": "mime", "value": "'json'"}, {"name": "case_data", "value": "{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}"}, {"name": "expect_data", "value": "{'message': '添加组织成功'}"}, {"name": "sql_data", "value": "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}"}, {"name": "sql_type", "value": "'select|delete'"}, {"name": "update_key", "value": "'demId'"}], "start": 1716272642365, "stop": 1716272642541, "uuid": "02a9a62e-8cd4-4d16-a6ad-5c9ae83ed3d4", "historyId": "526f1fd519b78b4955668d6cfd277048", "testCaseId": "8c3ca9784f7a20f46f527b41c7204e5a", "fullName": "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "组织管理"}, {"name": "story", "value": "添加组织"}, {"name": "severity", "value": "高"}, {"name": "epic", "value": "BPM系统-老张"}, {"name": "parentSuite", "value": "test_case.test_mirZhang"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_mirZhang.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/d7571898-6dd0-447c-bc2a-094d144ec9da-container.json

+{"uuid": "ac0473d8-03ac-40d9-8762-a99f28224867", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272599527, "stop": 1716272599527}], "start": 1716272599527, "stop": 1716272599629}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/d77401e5-4d45-4c27-8d6f-dc289c8f1f37-container.json

+{"uuid": "41ab22dc-1841-44c2-ba7f-24c5c195614e", "befores": [{"name": "api_name", "status": "passed", "start": 1716272644557, "stop": 1716272644557}], "start": 1716272644557, "stop": 1716272644751}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/d7e33b10-07f4-46ca-84b3-720c05e49cbd-container.json

+{"uuid": "98bc8393-d1de-4680-8022-e36888927a8a", "befores": [{"name": "case_title", "status": "passed", "start": 1716272621598, "stop": 1716272621598}], "start": 1716272621598, "stop": 1716272621789}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/d8b8b17c-bc8b-40dc-b90a-2d76eb839c26-container.json

+{"uuid": "ce3f5bd5-30c6-41cc-b780-a09288e9cc93", "befores": [{"name": "module_name", "status": "passed", "start": 1716272644755, "stop": 1716272644755}], "start": 1716272644755, "stop": 1716272644813}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/d8ce2e75-c48d-4556-8f15-10d82113515d-container.json

+{"uuid": "7d6a1585-dbef-4a0c-9b14-d264362699ed", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272610397, "stop": 1716272610397}], "start": 1716272610397, "stop": 1716272610535}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/d914deef-3254-429b-93b1-ce774046aba9-container.json

+{"uuid": "94fc8ced-5e50-4d41-ba3a-5739d2b00748", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272633396, "stop": 1716272633396}], "start": 1716272633396, "stop": 1716272633537}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/d993550e-3284-4071-9240-5f178c323d76-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTg5OTgsImlhdCI6MTcxNjI3MjU5OH0.4JgpWuf9sSQnYV9dPIhf0I76OkCqUlLws0abjIB0nEM_iXrT2qd79jiUvk3kiwUvDIw9aHYQdvVjAFq8AQLNCw","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDAsImlhdCI6MTcxNjI3MjYwMH0.atAGdmkk-bhC9iAhggDWp0VlgVLl39hN3_u2ytWqmjm1GWT-vhDYRgCax56GrBuR6EkPJEseXgX-S8EfzoWXhg","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDIsImlhdCI6MTcxNjI3MjYwMn0.2ULfoTRcxys6pnuEKjHxZH4GI20D2qBisJFYoBn2GdZLw23Xapl1u2ATzI1w5cFlBcJf3_bFyVN7eo7OfOOMUg","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTkwMDQsImlhdCI6MTcxNjI3MjYwNH0.TOXPdeAD96XQ_Maa-ITQDDQZTnKhlW09esTDC6-C8_Wux9HSk3bWURoOvhmcidK-lCj4Tvw1ZO0dYFWGR8-lsg","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/d9952e60-1002-4a96-8d4c-bf623cfef70e-container.json

+{"uuid": "7d428463-d5f3-435a-bdf5-d937f4fb1ac4", "befores": [{"name": "api_name", "status": "passed", "start": 1716272614966, "stop": 1716272614966}], "start": 1716272614966, "stop": 1716272615157}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/d9ff77a6-280a-4575-84fe-c8a622baaf42-container.json

+{"uuid": "9bc1217f-4380-4434-9246-3471d4a3463d", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272612749, "stop": 1716272612749}], "start": 1716272612749, "stop": 1716272612939}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/da25044c-10c5-4549-af38-e62898d735d7-container.json

+{"uuid": "ffe62b30-2b2c-4402-8dbc-31c0261256e5", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272602024, "stop": 1716272602024}], "start": 1716272602024, "stop": 1716272602081}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/da662e8f-2f00-414a-a44c-a996ac51f7bf-container.json

+{"uuid": "5c9be1ae-2f77-474f-8e43-cf68690cb139", "befores": [{"name": "case_data", "status": "passed", "start": 1716272599315, "stop": 1716272599315}], "start": 1716272599315, "stop": 1716272599411}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/da6a994c-cb3d-49ff-ba10-0a4dbeb54d00-container.json

+{"uuid": "31d5a57f-95a8-456a-b563-0c30f7313942", "befores": [{"name": "case_data", "status": "passed", "start": 1716272598828, "stop": 1716272598828}], "start": 1716272598828, "stop": 1716272598887}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/da6ec2b4-d884-46cd-984f-cc05d2a949dc-container.json

+{"uuid": "c9bc1b4c-cc72-43ca-94bf-53391668f1ca", "befores": [{"name": "case_data", "status": "passed", "start": 1716272602023, "stop": 1716272602023}], "start": 1716272602023, "stop": 1716272602082}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/dac74899-5b1b-4394-9c10-ec236c6b4241-container.json

+{"uuid": "e69b4f5a-7273-4523-9d5b-5aa9a4b99ac7", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272628365, "stop": 1716272628365}], "start": 1716272628365, "stop": 1716272628511}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/daeebeb7-2cb4-4f62-bd27-ca2166dc21fb-container.json

+{"uuid": "02b21273-1bfa-43a2-b725-0706d2f732ef", "befores": [{"name": "method", "status": "passed", "start": 1716272608243, "stop": 1716272608243}], "start": 1716272608243, "stop": 1716272608305}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/db394d98-cdaa-42a6-bd10-49adba7739a5-attachment.txt

+断言

InterfaceAutoTest/report/allure/json/db5f9a39-ba19-4267-ac1d-c55dd7e2b164-container.json

+{"uuid": "f08a0b40-fccd-40f7-9f23-8b048421ed76", "befores": [{"name": "method", "status": "passed", "start": 1716272621986, "stop": 1716272621986}], "start": 1716272621986, "stop": 1716272622090}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/dbda4c3f-ae3e-4116-a81a-6b27471e5e73-attachment.txt

+断言

InterfaceAutoTest/report/allure/json/dc894428-fbb4-431a-9584-dc6c2af5ad9f-container.json

+{"uuid": "7a46243d-89b3-4af4-b62d-9b0db17243ab", "befores": [{"name": "url", "status": "passed", "start": 1716272614966, "stop": 1716272614966}], "start": 1716272614966, "stop": 1716272615156}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/dd34af05-c80a-470e-9cb0-848333f9724e-container.json

+{"uuid": "59d27c2f-0f2c-4681-94a4-a5a2fddaaa62", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272651357, "stop": 1716272651357}], "start": 1716272651357, "stop": 1716272651500}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/dd5df6a4-3cc5-4440-8180-bb6b8f6dee02-container.json

+{"uuid": "b41b9abb-c69a-4ff5-bff8-c5c29d410c9e", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272628365, "stop": 1716272628365}], "start": 1716272628365, "stop": 1716272628509}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/df7285d1-d7a6-483c-98fa-b8e0dededf20-container.json

+{"uuid": "f5f97929-7545-426d-adeb-c1512323daee", "befores": [{"name": "mime", "status": "passed", "start": 1716272621599, "stop": 1716272621599}], "start": 1716272621599, "stop": 1716272621788}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/e0136be4-a713-4ed8-a3f9-05b3449b8341-container.json

+{"uuid": "d49a842e-2cff-4734-a0c4-ebeac6cd39d9", "befores": [{"name": "url", "status": "passed", "start": 1716272621855, "stop": 1716272621855}], "start": 1716272621855, "stop": 1716272621915}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/e0e6eb41-195e-43ee-85ed-a0ccba0547af-container.json

+{"uuid": "a7ce25e5-ce10-4cfe-93a7-04fc7b788e63", "befores": [{"name": "url", "status": "passed", "start": 1716272644557, "stop": 1716272644557}], "start": 1716272644557, "stop": 1716272644750}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/e106cb11-d5a2-4453-940b-a818816cb5dc-container.json

+{"uuid": "7cbf4bb9-f4b0-421a-b9c0-22e9f6cfc010", "befores": [{"name": "module_name", "status": "passed", "start": 1716272621986, "stop": 1716272621986}], "start": 1716272621986, "stop": 1716272622090}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/e1ec4b0e-3fdc-4f31-adf9-549c204d8b87-container.json

+{"uuid": "3936f81b-1554-4f9d-b3a0-d36ab08ceaab", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272632685, "stop": 1716272632685}], "start": 1716272632685, "stop": 1716272632829}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/e219ae78-a9b4-41b2-8734-bc4328bd82d7-result.json

+{"name": "正向用例-正确输入用户名和密码", "status": "passed", "attachments": [{"name": "log", "source": "76cb374f-acab-4726-b9aa-2a71d34cda4f-attachment.txt", "type": "text/plain"}, {"name": "stdout", "source": "641690dc-554a-4a04-be37-4a9e72b43fbb-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'认证接口'"}, {"name": "api_name", "value": "'登录系统'"}, {"name": "case_title", "value": "'正向用例-正确输入用户名和密码'"}, {"name": "case_level", "value": "'高'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/auth'"}, {"name": "mime", "value": "'application/json'"}, {"name": "case_data", "value": "{'username': 'admin', 'password': 'MTIzNDU2'}"}, {"name": "expect_data", "value": "{'username': '超级管理员', 'loginStatus': True, 'account': 'admin'}"}, {"name": "sql_data", "value": "None"}, {"name": "sql_type", "value": "None"}, {"name": "update_key", "value": "None"}], "start": 1716272598748, "stop": 1716272598811, "uuid": "de6e8ca1-3977-41fc-8592-037ad0e4f8ac", "historyId": "f7417fae3641334c555177156c21126d", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "认证接口"}, {"name": "story", "value": "登录系统"}, {"name": "severity", "value": "高"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/e231a69a-a004-4912-9a4d-ecf964dd316e-result.json

+{"name": "反向用例-用户名正确,密码为空", "status": "passed", "attachments": [{"name": "log", "source": "30644989-5621-4560-aa28-6e80eb68bc49-attachment.txt", "type": "text/plain"}, {"name": "stdout", "source": "050f736a-4c14-4161-bff8-c02c54307aeb-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'认证接口'"}, {"name": "api_name", "value": "'登录系统'"}, {"name": "case_title", "value": "'反向用例-用户名正确,密码为空'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/auth'"}, {"name": "mime", "value": "'application/json'"}, {"name": "case_data", "value": "{'username': 'admin', 'password': ''}"}, {"name": "expect_data", "value": "{'message': '账号或密码错误'}"}, {"name": "sql_data", "value": "None"}, {"name": "sql_type", "value": "None"}, {"name": "update_key", "value": "None"}], "start": 1716272598829, "stop": 1716272598886, "uuid": "040bef0e-8054-4a69-ad83-12b8493dc82d", "historyId": "4164dfc118ea6cc8eeb9ce3984609436", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "认证接口"}, {"name": "story", "value": "登录系统"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/e2ad78a7-679a-4efd-81d2-aa517a2c9177-container.json

+{"uuid": "6a4f5536-cbe0-4339-86b2-0b1420c7d62a", "befores": [{"name": "module_name", "status": "passed", "start": 1716272621919, "stop": 1716272621920}], "start": 1716272621919, "stop": 1716272621984}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/e3a12218-09fa-4eb4-9558-ca29aafd71ff-container.json

+{"uuid": "0aa4ceea-83b3-4186-836e-fb453ff0e1d5", "befores": [{"name": "update_key", "status": "passed", "start": 1716272637956, "stop": 1716272637956}], "start": 1716272637956, "stop": 1716272638145}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/e3c51284-344e-42da-b47d-f849664f5f0e-container.json

+{"uuid": "8fbbcfef-bf4a-49d4-b1ed-fa5328c76859", "befores": [{"name": "case_level", "status": "passed", "start": 1716272610541, "stop": 1716272610541}], "start": 1716272610541, "stop": 1716272610736}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/e4e3b89c-5644-49fb-97fa-55d06b653e0a-container.json

+{"uuid": "6bd58ecb-2dfa-49f3-a6f3-ac9373934bcf", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272626206, "stop": 1716272626206}], "start": 1716272626206, "stop": 1716272626350}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/e4f81c53-2607-433c-98de-ad3881ca8134-container.json

+{"uuid": "ee0e5bfc-0650-4221-a206-42cac0cde588", "befores": [{"name": "case_title", "status": "passed", "start": 1716272599417, "stop": 1716272599417}], "start": 1716272599417, "stop": 1716272599523}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/e520fe8d-3cb1-4ad2-ae73-385ca9946df6-container.json

+{"uuid": "ce7f642a-5eba-4af1-ab77-0f61c4bc4770", "befores": [{"name": "method", "status": "passed", "start": 1716272610541, "stop": 1716272610541}], "start": 1716272610541, "stop": 1716272610735}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/e5944734-33ca-4539-8662-aab0f8453444-container.json

+{"uuid": "7770c3f2-7735-4c3d-80fa-4959389efe20", "befores": [{"name": "module_name", "status": "passed", "start": 1716272644957, "stop": 1716272644958}], "start": 1716272644957, "stop": 1716272645067}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/e62cc822-0620-41c7-8bb5-0b63878d429c-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/e6848330-c0fc-43ff-8086-b7296c692063-container.json

+{"uuid": "4f59778f-ce0c-4773-9314-e4b04ab6420a", "befores": [{"name": "update_key", "status": "passed", "start": 1716272599418, "stop": 1716272599418}], "start": 1716272599418, "stop": 1716272599518}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/e70e4a25-a750-4cfb-abf3-8f80d8c5b372-container.json

+{"uuid": "7b96c188-8c3c-4096-bfdf-9316bfa82752", "befores": [{"name": "case_title", "status": "passed", "start": 1716272599102, "stop": 1716272599102}], "start": 1716272599102, "stop": 1716272599207}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/e78097d6-f262-4f12-9f73-2ac425814e91-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792803379156631552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/e796c653-7079-4534-8a3a-3e0b0136d39f-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功", "trace": "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179923A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "0453ac8d-bc38-4c0b-bd86-e5bd9e1535a5-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'组织管理'"}, {"name": "api_name", "value": "'添加组织'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'高'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/org/v1/org/addOrg'"}, {"name": "mime", "value": "'json'"}, {"name": "case_data", "value": "{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}"}, {"name": "expect_data", "value": "{'message': '添加组织成功'}"}, {"name": "sql_data", "value": "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}"}, {"name": "sql_type", "value": "'select|delete'"}, {"name": "update_key", "value": "'demId'"}], "start": 1716272612750, "stop": 1716272612931, "uuid": "9714c1e1-0859-468b-be86-852340c61f79", "historyId": "487ae598a2b30a5ea2489bb3e5fa08a4", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "组织管理"}, {"name": "story", "value": "添加组织"}, {"name": "severity", "value": "高"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/e851664d-0e77-43ed-8a02-5227d9d696b1-container.json

+{"uuid": "7be3fc08-8e0a-49f4-bf05-80b1fde18d9b", "befores": [{"name": "api_name", "status": "passed", "start": 1716272624097, "stop": 1716272624097}], "start": 1716272624097, "stop": 1716272624197}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/e89e1fb9-1a88-4c82-ac05-e068bad294fa-container.json

+{"uuid": "b9794b91-e61b-4096-a046-4cf84b69feb3", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272640167, "stop": 1716272640167}], "start": 1716272640167, "stop": 1716272640349}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/e8b0ee5f-2c9e-4ded-9353-dc97679795be-container.json

+{"uuid": "ec8d097f-12a8-46b4-a629-037ccaf2291b", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272598998, "stop": 1716272598998}], "start": 1716272598998, "stop": 1716272599094}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/e971fff6-7eb6-40af-a1a6-1456bb379c82-container.json

+{"uuid": "22469b1a-e05e-47c6-a819-a6e6382bc48f", "befores": [{"name": "case_data", "status": "passed", "start": 1716272624098, "stop": 1716272624098}], "start": 1716272624098, "stop": 1716272624194}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/e981a87a-1521-44b2-9ffb-ecc462d61106-container.json

+{"uuid": "b883cc73-5c67-4822-a813-f7852a97b68f", "befores": [{"name": "method", "status": "passed", "start": 1716272630525, "stop": 1716272630525}], "start": 1716272630525, "stop": 1716272630670}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/e9b5fafe-e804-4d1d-9883-a5bc35e4d52c-container.json

+{"uuid": "fa6946f5-5904-4bde-8ec3-bed30e92318e", "befores": [{"name": "mime", "status": "passed", "start": 1716272612749, "stop": 1716272612749}], "start": 1716272612749, "stop": 1716272612949}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/e9cd574f-b9f0-479d-ba36-fc94c3c436cb-container.json

+{"uuid": "64312298-0f39-48e9-a811-0a24f76d4aab", "befores": [{"name": "module_name", "status": "passed", "start": 1716272602023, "stop": 1716272602023}], "start": 1716272602023, "stop": 1716272602085}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/e9ea0a37-15e4-4b2f-9e8f-555fd120cb8c-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功", "trace": "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "01e18fd9-42f9-4bcd-974a-5d536b223172-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'维度管理'"}, {"name": "api_name", "value": "'根据维度编码删除维度'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'DELETE'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'"}, {"name": "mime", "value": "'query'"}, {"name": "case_data", "value": "{'ids': '1792803475629817856'}"}, {"name": "expect_data", "value": "{'message': '删除维度成功'}"}, {"name": "sql_data", "value": "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"}, {"name": "sql_type", "value": "'select'"}, {"name": "update_key", "value": "'ids'"}], "start": 1716272649197, "stop": 1716272649328, "uuid": "5bd4b2f2-3756-447e-85d2-f91d79c74336", "historyId": "f0f670cbfec7a9680aec241c756307a6", "testCaseId": "8c3ca9784f7a20f46f527b41c7204e5a", "fullName": "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "维度管理"}, {"name": "story", "value": "根据维度编码删除维度"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-老张"}, {"name": "parentSuite", "value": "test_case.test_mirZhang"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_mirZhang.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/eacdfa40-9d2a-4b3c-8050-8a21634b5845-container.json

+{"uuid": "2b6dc004-45ec-4af7-96e2-5c3011631695", "befores": [{"name": "method", "status": "passed", "start": 1716272644882, "stop": 1716272644882}], "start": 1716272644882, "stop": 1716272644952}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/ead9f847-8ab2-47b6-8d7d-1f0909efabce-container.json

+{"uuid": "6d0f11d5-70e3-43df-8253-c35edd0d447b", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272655685, "stop": 1716272655685}], "start": 1716272655685, "stop": 1716272655834}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/eb24a842-5144-4abb-99dc-8ab80a156e35-container.json

+{"uuid": "d8602e03-94e8-46de-bb67-d0a59a7c42c4", "befores": [{"name": "api_name", "status": "passed", "start": 1716272599102, "stop": 1716272599102}], "start": 1716272599102, "stop": 1716272599208}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/eb70019e-d464-42a5-a986-dc1347bcdd51-container.json

+{"uuid": "be5b1b44-54c5-4b9c-a641-e4936172158d", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272602024, "stop": 1716272602024}], "start": 1716272602024, "stop": 1716272602081}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/ec1e10eb-b0ad-4cfb-b8f5-d2f821e29022-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功", "trace": "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F1903D190>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803475629817856'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "4f123ded-0b4f-415d-961e-3f0c77fa19a2-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'维度管理'"}, {"name": "api_name", "value": "'根据维度编码删除维度'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'DELETE'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'"}, {"name": "mime", "value": "'query'"}, {"name": "case_data", "value": "{'ids': '1792803475629817856'}"}, {"name": "expect_data", "value": "{'message': '删除维度成功'}"}, {"name": "sql_data", "value": "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"}, {"name": "sql_type", "value": "'select'"}, {"name": "update_key", "value": "'ids'"}], "start": 1716272655685, "stop": 1716272655817, "uuid": "e282fa20-5a3f-4279-9225-bad545b3bb44", "historyId": "f0f670cbfec7a9680aec241c756307a6", "testCaseId": "8c3ca9784f7a20f46f527b41c7204e5a", "fullName": "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "维度管理"}, {"name": "story", "value": "根据维度编码删除维度"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-老张"}, {"name": "parentSuite", "value": "test_case.test_mirZhang"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_mirZhang.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/ec4be7d1-d190-4776-883d-cd715bf4278f-container.json

+{"uuid": "71126275-c722-46b1-b844-6ad2787ed1f6", "befores": [{"name": "update_key", "status": "passed", "start": 1716272598893, "stop": 1716272598893}], "start": 1716272598893, "stop": 1716272598989}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/ec52c380-b907-473d-bde2-afa483962036-container.json

+{"uuid": "cc1f6160-7dad-410d-8b2d-08c977668641", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272621987, "stop": 1716272621987}], "start": 1716272621987, "stop": 1716272622087}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/ec79074a-6297-452d-b3e6-c093a4a985fc-container.json

+{"uuid": "080f2b0c-fac9-408b-9715-2c5ca216cd8a", "befores": [{"name": "method", "status": "passed", "start": 1716272633543, "stop": 1716272633543}], "start": 1716272633543, "stop": 1716272633730}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/ec7ebd18-ba5d-41ef-a845-4db2bc23b97a-container.json

+{"uuid": "8eb49550-8808-4801-8eba-1f659bec8fc8", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272644958, "stop": 1716272644958}], "start": 1716272644958, "stop": 1716272645062}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/ed02f594-4adf-480a-b387-950b0fcb1ef5-container.json

+{"uuid": "9baff91a-1ea3-4db8-b36b-81b631bf33cd", "befores": [{"name": "url", "status": "passed", "start": 1716272651357, "stop": 1716272651357}], "start": 1716272651357, "stop": 1716272651502}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/ed2f00ac-9904-4fe4-8f62-6b20612d0fac-result.json

+{"name": "正向用例", "status": "passed", "attachments": [{"name": "log", "source": "1a5a808f-02c9-421a-8759-a657843dcdd6-attachment.txt", "type": "text/plain"}, {"name": "stdout", "source": "4fc57b0e-88e2-4150-a1a0-afa2c27af05c-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'维度管理'"}, {"name": "api_name", "value": "'添加维度'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'高'"}, {"name": "method", "value": "'pOst'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/demension/v1/dem/addDem'"}, {"name": "mime", "value": "'json'"}, {"name": "case_data", "value": "{'code': 'api_auto_test_add_dem', 'description': 'api_auto_test_add_dem', 'isDefault': 0, 'name': 'api_auto_test_add_dem'}"}, {"name": "expect_data", "value": "{'message': '添加维度成功！'}"}, {"name": "sql_data", "value": "'delete FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"}, {"name": "sql_type", "value": "'delete'"}, {"name": "update_key", "value": "None"}], "start": 1716272610398, "stop": 1716272610534, "uuid": "a2af0d1d-aaf2-479d-85f6-b3a86b65fa84", "historyId": "435ba53246b35b4af7286c32ad75fe23", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "维度管理"}, {"name": "story", "value": "添加维度"}, {"name": "severity", "value": "高"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/ed580447-e961-4ae3-b0f8-878e3b17962b-container.json

+{"uuid": "4bb5e7bd-563f-4f23-888a-e6dcbaf98caf", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272633543, "stop": 1716272633543}], "start": 1716272633543, "stop": 1716272633729}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/edb607af-88bd-4b64-8430-591655c94b18-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/ee078ad5-03b9-4121-95cc-854814412110-container.json

+{"uuid": "fe9eef79-0e64-42ae-b5ae-73ce4cbd32bd", "befores": [{"name": "case_data", "status": "passed", "start": 1716272610325, "stop": 1716272610325}], "start": 1716272610325, "stop": 1716272610392}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/ee7f99ef-af40-4d8e-b3d9-b931394c63a4-container.json

+{"uuid": "5b0b5785-4994-4e52-abdc-a0cecb6fb3a7", "befores": [{"name": "case_data", "status": "passed", "start": 1716272599527, "stop": 1716272599527}], "start": 1716272599527, "stop": 1716272599631}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/ef20beec-8782-4981-a1cd-c3c31c39469e-container.json

+{"uuid": "24b064d8-574a-4e84-8d81-6dc3d7fc22a2", "befores": [{"name": "module_name", "status": "passed", "start": 1716272599417, "stop": 1716272599417}], "start": 1716272599417, "stop": 1716272599523}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/ef9f5c84-7f55-461b-aaba-e32266ff0170-container.json

+{"uuid": "fe41d33b-ad9e-4baf-8284-f374778500ee", "befores": [{"name": "api_name", "status": "passed", "start": 1716272612749, "stop": 1716272612749}], "start": 1716272612749, "stop": 1716272612951}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/f0d73289-0b63-4cb1-b728-7302fc1acc55-attachment.txt

+断言

InterfaceAutoTest/report/allure/json/f11511e7-514e-4cae-9947-9ece1b6546a8-container.json

+{"uuid": "50fa53ab-ca33-4d06-9cab-cef764c610b5", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272621856, "stop": 1716272621856}], "start": 1716272621856, "stop": 1716272621913}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/f256ffd5-7d5b-4ffc-8635-1fe8a78a29c8-container.json

+{"uuid": "d55adf90-b637-4d9c-8fb1-35bc68e0f11c", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272628365, "stop": 1716272628365}], "start": 1716272628365, "stop": 1716272628509}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/f26764da-29cf-42d7-8511-588fcb528175-container.json

+{"uuid": "362d65da-0de2-4771-9b2f-e227e3a221bb", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272621795, "stop": 1716272621795}], "start": 1716272621795, "stop": 1716272621849}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/f32b9fa9-dd86-4adf-8677-720bb86e600a-container.json

+{"uuid": "63c3a822-e0aa-4c5c-beea-ca433cb8ae08", "befores": [{"name": "module_name", "status": "passed", "start": 1716272640166, "stop": 1716272640166}], "start": 1716272640166, "stop": 1716272640352}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/f3cf8b50-5f89-4dc7-a2dd-b9d4ef32fa63-container.json

+{"uuid": "e16a54c7-78bf-44b0-be69-1d3fee75966f", "befores": [{"name": "update_key", "status": "passed", "start": 1716272604095, "stop": 1716272604095}], "start": 1716272604095, "stop": 1716272604153}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/f3f06fcf-c8db-47ff-8a8d-d69770a0dce4-container.json

+{"uuid": "eb58e06b-b5b0-44dc-bfb0-cedfced18bbf", "befores": [{"name": "case_title", "status": "passed", "start": 1716272644557, "stop": 1716272644557}], "start": 1716272644557, "stop": 1716272644751}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/f44eae75-7e0f-44a3-8d86-8f8d7d9caa42-container.json

+{"uuid": "10807cfe-c144-4fd5-87ef-4d557f95121f", "befores": [{"name": "module_name", "status": "passed", "start": 1716272624097, "stop": 1716272624097}], "start": 1716272624097, "stop": 1716272624197}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/f4d14023-accb-4d3e-a942-64bbaf6edb04-container.json

+{"uuid": "42d54d40-0096-4734-b013-02354556fdb4", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272599527, "stop": 1716272599527}], "start": 1716272599527, "stop": 1716272599630}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/f4eb1b14-f01c-4cea-8027-fd9d7eb6b4e7-container.json

+{"uuid": "fe853f73-a0a2-43cb-b55d-c48717779436", "befores": [{"name": "api_name", "status": "passed", "start": 1716272642364, "stop": 1716272642364}], "start": 1716272642364, "stop": 1716272642551}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/f5975aae-74bc-4408-8fba-131356a59f72-container.json

+{"uuid": "1650c420-00ee-4908-b92e-6e37146a8ce8", "befores": [{"name": "method", "status": "passed", "start": 1716272655684, "stop": 1716272655684}], "start": 1716272655684, "stop": 1716272655836}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/f5c35a4f-ffb4-46de-bc2d-09cc8aea21ad-container.json

+{"uuid": "dd9539f0-93b9-45fe-b54f-dfb86ad5bca9", "befores": [{"name": "module_name", "status": "passed", "start": 1716272610397, "stop": 1716272610397}], "start": 1716272610397, "stop": 1716272610538}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/f6710333-f328-4e0d-922b-95e852462df9-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNTg5OTgsImlhdCI6MTcxNjI3MjU5OH0.4JgpWuf9sSQnYV9dPIhf0I76OkCqUlLws0abjIB0nEM_iXrT2qd79jiUvk3kiwUvDIw9aHYQdvVjAFq8AQLNCw","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/f694cf5e-af33-467a-9332-d9765b3504bc-result.json

+{"name": "正向用例", "status": "passed", "attachments": [{"name": "log", "source": "c9eae618-f036-47fc-b558-11e55e37943b-attachment.txt", "type": "text/plain"}, {"name": "stdout", "source": "63ed9fbf-6772-47c7-bc71-cc7c376a16d9-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'维度管理'"}, {"name": "api_name", "value": "'添加维度'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'高'"}, {"name": "method", "value": "'pOst'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/demension/v1/dem/addDem'"}, {"name": "mime", "value": "'json'"}, {"name": "case_data", "value": "{'code': 'api_auto_test_add_dem', 'description': 'api_auto_test_add_dem', 'isDefault': 0, 'name': 'api_auto_test_add_dem'}"}, {"name": "expect_data", "value": "{'message': '添加维度成功！'}"}, {"name": "sql_data", "value": "'delete FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"}, {"name": "sql_type", "value": "'delete'"}, {"name": "update_key", "value": "None"}], "start": 1716272633398, "stop": 1716272633535, "uuid": "3a61f8e2-29b1-46e9-99ff-83ea06718f5d", "historyId": "aab084bf6a05ec45b335f51ecc264b7e", "testCaseId": "8c3ca9784f7a20f46f527b41c7204e5a", "fullName": "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "维度管理"}, {"name": "story", "value": "添加维度"}, {"name": "severity", "value": "高"}, {"name": "epic", "value": "BPM系统-老张"}, {"name": "parentSuite", "value": "test_case.test_mirZhang"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_mirZhang.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/f6a26d79-c4d5-4ddb-889b-b7a215f80439-container.json

+{"uuid": "19f2675a-9b65-49e2-bca8-b6e9ddf43dcd", "befores": [{"name": "case_level", "status": "passed", "start": 1716272644816, "stop": 1716272644816}], "start": 1716272644816, "stop": 1716272644877}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/f761392d-7b9d-4637-ad1a-ac9a2da51a93-container.json

+{"uuid": "018cfdf6-1685-434e-a34f-0fc24c2f6c8a", "befores": [{"name": "module_name", "status": "passed", "start": 1716272621794, "stop": 1716272621794}], "start": 1716272621794, "stop": 1716272621852}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/f83e729a-d1e0-4b27-8022-ff6de35308bb-container.json

+{"uuid": "082bc456-60db-4aa8-aae1-852e67da81fb", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272644756, "stop": 1716272644756}], "start": 1716272644756, "stop": 1716272644811}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/f929075f-ee33-49a4-a623-47a38abbedc2-container.json

+{"uuid": "c3e4620d-2ee1-4f83-8ec9-cabbc0406cdc", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272630526, "stop": 1716272630526}], "start": 1716272630526, "stop": 1716272630668}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/f93b1ef3-3770-440d-955e-942d9c89e5a3-container.json

+{"uuid": "df74fb72-f1cc-43cd-904a-5a5e3b8f9a59", "befores": [{"name": "mime", "status": "passed", "start": 1716272610325, "stop": 1716272610325}], "start": 1716272610325, "stop": 1716272610392}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/f96bb7cf-7da0-47f0-810b-3757e04903e4-container.json

+{"uuid": "502166e1-14e4-4a30-b5d1-5444c14c3e10", "befores": [{"name": "update_key", "status": "passed", "start": 1716272621599, "stop": 1716272621599}], "start": 1716272621599, "stop": 1716272621787}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/f9d4efd3-02f1-4d34-b8e3-46937d4e96be-container.json

+{"uuid": "99879375-d4f3-4d66-a1a8-d293f74f5103", "befores": [{"name": "url", "status": "passed", "start": 1716272612749, "stop": 1716272612749}], "start": 1716272612749, "stop": 1716272612949}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/f9edf817-e49b-4c7c-aadf-a0d809f6efe0-container.json

+{"uuid": "74c1e657-aea4-4519-b0ce-722e3ce6b7df", "befores": [{"name": "module_name", "status": "passed", "start": 1716272621598, "stop": 1716272621598}], "start": 1716272621598, "stop": 1716272621791}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/f9f88b76-a4d7-433b-9a4a-3e7047352f83-container.json

+{"uuid": "20a04cbe-694e-40b2-9b73-3efb1b5adbd8", "befores": [{"name": "api_name", "status": "passed", "start": 1716272599639, "stop": 1716272599639}], "start": 1716272599639, "stop": 1716272599740}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/fa2a7529-72ed-4d3f-ba3f-3c56a65928e9-container.json

+{"uuid": "0430f003-fb9d-4a4b-a984-1509dd072829", "befores": [{"name": "case_data", "status": "passed", "start": 1716272644882, "stop": 1716272644882}], "start": 1716272644882, "stop": 1716272644950}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/fa78cf4d-5d2d-4aed-a776-fc2fa8df2c38-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功", "trace": "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "32307c09-b496-435f-bba5-c2798db7be07-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'维度管理'"}, {"name": "api_name", "value": "'根据维度编码删除维度'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'DELETE'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'"}, {"name": "mime", "value": "'query'"}, {"name": "case_data", "value": "{'ids': '1792803379156631552'}"}, {"name": "expect_data", "value": "{'message': '删除维度成功'}"}, {"name": "sql_data", "value": "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"}, {"name": "sql_type", "value": "'select'"}, {"name": "update_key", "value": "'ids'"}], "start": 1716272624099, "stop": 1716272624187, "uuid": "47742522-0ccb-41e1-bbc6-814171df56f5", "historyId": "347d2f73ed73495ba7ba72dbf723f253", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "维度管理"}, {"name": "story", "value": "根据维度编码删除维度"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/facfa359-f4a9-4be8-85b3-90085422faa5-container.json

+{"uuid": "91c035d7-f6f1-4bd9-b799-c5f904612d77", "befores": [{"name": "expect_data", "status": "passed", "start": 1716272632685, "stop": 1716272632685}], "start": 1716272632685, "stop": 1716272632830}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/fb0176f7-0989-4554-b4ac-310d80848f81-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  \n  - 添加组织成功！\n  ?       -\n  + 添加组织成功", "trace": "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000014F17992C70>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1923AE50>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1912F2B0>, module_name = '组织管理', api_name = '添加组织', case_title = '正向用例'\ncase_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', ...}\nexpect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 \nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "0c5a26e3-db88-4d6e-b01a-857990738541-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'组织管理'"}, {"name": "api_name", "value": "'添加组织'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'高'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/org/v1/org/addOrg'"}, {"name": "mime", "value": "'json'"}, {"name": "case_data", "value": "{'code': 'test_add_org', 'demId': '1792803475629817856', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}"}, {"name": "expect_data", "value": "{'message': '添加组织成功'}"}, {"name": "sql_data", "value": "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}"}, {"name": "sql_type", "value": "'select|delete'"}, {"name": "update_key", "value": "'demId'"}], "start": 1716272640167, "stop": 1716272640342, "uuid": "894a9818-f702-402c-855f-0eeb3a6d13aa", "historyId": "526f1fd519b78b4955668d6cfd277048", "testCaseId": "8c3ca9784f7a20f46f527b41c7204e5a", "fullName": "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "组织管理"}, {"name": "story", "value": "添加组织"}, {"name": "severity", "value": "高"}, {"name": "epic", "value": "BPM系统-老张"}, {"name": "parentSuite", "value": "test_case.test_mirZhang"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_mirZhang.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/fb1c5864-8539-453a-ae0e-a9f055759f94-container.json

+{"uuid": "1c2171cd-6ca4-4a38-bb0c-e5bfbe1d829e", "befores": [{"name": "case_title", "status": "passed", "start": 1716272610325, "stop": 1716272610325}], "start": 1716272610325, "stop": 1716272610393}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/fb2405b6-2cfa-473b-ad2a-4de6e8fb0064-container.json

+{"uuid": "ed97ad3d-c51a-429f-9a80-149fb10976fb", "befores": [{"name": "case_title", "status": "passed", "start": 1716272624097, "stop": 1716272624097}], "start": 1716272624097, "stop": 1716272624196}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/fc7abded-c9cb-4c99-8904-3e6b985bd531-container.json

+{"uuid": "e197eff1-4a8f-40ee-aa65-bf4d88ff01a6", "befores": [{"name": "case_level", "status": "passed", "start": 1716272602023, "stop": 1716272602023}], "start": 1716272602023, "stop": 1716272602083}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/fc9b3bae-d15e-4686-a396-4bc5a82f4a25-attachment.txt

+断言

InterfaceAutoTest/report/allure/json/fcf0e269-4266-4588-b63b-82148ec22cd8-attachment.txt

+断言

InterfaceAutoTest/report/allure/json/fdcfd21d-462e-47c1-b072-34ca6f9d4b60-container.json

+{"uuid": "0af6cbbf-4031-4cce-95e4-6c4d9de2d308", "befores": [{"name": "update_key", "status": "passed", "start": 1716272644756, "stop": 1716272644756}], "start": 1716272644756, "stop": 1716272644809}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/fe30cb30-283a-4756-bad3-66f16f9905d7-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'code': 'test_add_org', 'demId': '1792803379156631552', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}, 期望数据为:{'message': '添加组织成功'}, 服务器返回的数据为：{"state":true,"message":"添加组织成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/fe6a70b2-a15c-41e9-ba39-d84e2a9ff1b7-container.json

+{"uuid": "b693009b-47d7-4f9d-889e-f744ba4dfcb5", "befores": [{"name": "url", "status": "passed", "start": 1716272630525, "stop": 1716272630525}], "start": 1716272630525, "stop": 1716272630670}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/fe82dc1f-a68f-499a-b204-d17f7f5aad10-container.json

+{"uuid": "293e56bc-d430-49ee-a203-c5b526996962", "befores": [{"name": "method", "status": "passed", "start": 1716272637955, "stop": 1716272637955}], "start": 1716272637955, "stop": 1716272638149}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/fec3b58a-9cce-48d0-a23a-d586f14245c9-container.json

+{"uuid": "45459205-fc30-4666-8fd7-09dff3ecd489", "befores": [{"name": "sql_data", "status": "passed", "start": 1716272621795, "stop": 1716272621795}], "start": 1716272621795, "stop": 1716272621849}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/fee076fc-1039-4a70-ab56-b839d7fbd01d-container.json

+{"uuid": "4e945fce-33b8-4941-88a7-d31dc292ff64", "befores": [{"name": "url", "status": "passed", "start": 1716272640166, "stop": 1716272640166}], "start": 1716272640166, "stop": 1716272640350}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/ff1b7ef5-5c75-4e56-9781-3197149c28b8-attachment.txt

+断言

InterfaceAutoTest/report/allure/json/ff716806-b915-4865-a3fd-98f53bde6547-attachment.txt

+断言

InterfaceAutoTest/report/allure/json/ffbe6516-19ce-4f0b-a8c6-2bd7340fe967-container.json

+{"uuid": "b9cc96e8-bdb3-41e0-8a4d-dc032a57a66e", "befores": [{"name": "sql_type", "status": "passed", "start": 1716272626206, "stop": 1716272626206}], "start": 1716272626206, "stop": 1716272626349}
\ No newline at end of file

InterfaceAutoTest/report/allure/json/ffdc0bff-bded-4602-93d4-6abd42d0eda1-attachment.txt

+断言

InterfaceAutoTest/report/allure/json/ffe7c0db-bc57-4a28-9cfd-2cd73845ef92-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '删除维度成功' == ''\n  \n  + 删除维度成功", "trace": "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000014F179926A0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000014F1903D9D0>\ndb_fix = <InterfaceAutoTest.common.db.DB object at 0x0000014F1908BF10>, module_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例'\ncase_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds', mime = 'query'\ncase_data = {'ids': '1792803379156631552'}, expect_data = {'message': '删除维度成功'}\nsql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', sql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == ''\nE                 \nE                 + 删除维度成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "c555e677-f3d6-401b-a176-e1551e7f9383-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'维度管理'"}, {"name": "api_name", "value": "'根据维度编码删除维度'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'DELETE'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'"}, {"name": "mime", "value": "'query'"}, {"name": "case_data", "value": "{'ids': '1792803379156631552'}"}, {"name": "expect_data", "value": "{'message': '删除维度成功'}"}, {"name": "sql_data", "value": "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"}, {"name": "sql_type", "value": "'select'"}, {"name": "update_key", "value": "'ids'"}], "start": 1716272626207, "stop": 1716272626341, "uuid": "9813414c-29d3-4f07-bd19-9d6b147a1c80", "historyId": "347d2f73ed73495ba7ba72dbf723f253", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "维度管理"}, {"name": "story", "value": "根据维度编码删除维度"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "LAPTOP-O09782E1"}, {"name": "thread", "value": "8968-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/0024e590-b20b-4863-836a-3cca8e2dd742-container.json

+{"uuid": "4304143a-f3e4-4ed5-bee4-5ab6fa3e208d", "befores": [{"name": "expect_data", "status": "passed", "start": 1716277474338, "stop": 1716277474338}], "start": 1716277474338, "stop": 1716277474425}
+{"uuid": "4304143a-f3e4-4ed5-bee4-5ab6fa3e208d", "befores": [{"name": "expect_data", "status": "passed", "start": 1716277474338, "stop": 1716277474338}], "start": 1716277474338, "stop": 1716277474425}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/014abc15-4714-409b-b067-0cd0254f123c-container.json

+{"uuid": "54f18cf6-1ced-4b80-be9c-8583530cdff3", "befores": [{"name": "update_key", "status": "passed", "start": 1716277474546, "stop": 1716277474546}], "start": 1716277474546, "stop": 1716277474644}
+{"uuid": "54f18cf6-1ced-4b80-be9c-8583530cdff3", "befores": [{"name": "update_key", "status": "passed", "start": 1716277474546, "stop": 1716277474546}], "start": 1716277474546, "stop": 1716277474644}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/016813b0-612b-4fac-81bd-7771da7ac1a1-container.json

+{"uuid": "4bf90ce0-1a81-4f63-afd9-d14acb77ffb6", "befores": [{"name": "url", "status": "passed", "start": 1716277479714, "stop": 1716277479714}], "start": 1716277479714, "stop": 1716277479803}
+{"uuid": "4bf90ce0-1a81-4f63-afd9-d14acb77ffb6", "befores": [{"name": "url", "status": "passed", "start": 1716277479714, "stop": 1716277479714}], "start": 1716277479714, "stop": 1716277479803}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/025d541a-c12e-4dee-b944-97e4137f68af-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  - 添加组织成功！\n  ?       -\n  + 添加组织成功", "trace": "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000027C56126030>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000027C563A7C20>, db_fix = <InterfaceAutoTest.common.db.DB object at 0x0000027C564B5580>\nmodule_name = '组织管理', api_name = '添加组织', case_title = '正向用例', case_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792823812232855552', 'exceedLimitNum': 0, 'grade': '', ...}, expect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000027C56126030>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000027C563A7C20>, db_fix = <InterfaceAutoTest.common.db.DB object at 0x0000027C564B5580>\nmodule_name = '组织管理', api_name = '添加组织', case_title = '正向用例', case_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792823812232855552', 'exceedLimitNum': 0, 'grade': '', ...}, expect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "c4acdd48-835a-4cf8-ad9b-17c2ce77bc60-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'组织管理'"}, {"name": "api_name", "value": "'添加组织'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'高'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/org/v1/org/addOrg'"}, {"name": "mime", "value": "'json'"}, {"name": "case_data", "value": "{'code': 'test_add_org', 'demId': '需要更新', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}"}, {"name": "expect_data", "value": "{'message': '添加组织成功'}"}, {"name": "sql_data", "value": "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}"}, {"name": "sql_type", "value": "'select|delete'"}, {"name": "update_key", "value": "'demId'"}], "start": 1716277479315, "stop": 1716277479562, "uuid": "22b4c7d5-e7f1-43f8-be91-8c1ac1fe3c34", "historyId": "775a6ff6df9900840ea55e63958ed107", "testCaseId": "8c3ca9784f7a20f46f527b41c7204e5a", "fullName": "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "组织管理"}, {"name": "story", "value": "添加组织"}, {"name": "severity", "value": "高"}, {"name": "epic", "value": "BPM系统-老张"}, {"name": "parentSuite", "value": "test_case.test_mirZhang"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "DESKTOP-4FFIKGU"}, {"name": "thread", "value": "4400-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_mirZhang.test_bpm"}]}
+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  - 添加组织成功！\n  ?       -\n  + 添加组织成功", "trace": "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000027C56126030>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000027C563A7C20>, db_fix = <InterfaceAutoTest.common.db.DB object at 0x0000027C564B5580>\nmodule_name = '组织管理', api_name = '添加组织', case_title = '正向用例', case_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792823812232855552', 'exceedLimitNum': 0, 'grade': '', ...}, expect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000027C56126030>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000027C563A7C20>, db_fix = <InterfaceAutoTest.common.db.DB object at 0x0000027C564B5580>\nmodule_name = '组织管理', api_name = '添加组织', case_title = '正向用例', case_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792823812232855552', 'exceedLimitNum': 0, 'grade': '', ...}, expect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "c4acdd48-835a-4cf8-ad9b-17c2ce77bc60-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'组织管理'"}, {"name": "api_name", "value": "'添加组织'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'高'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/org/v1/org/addOrg'"}, {"name": "mime", "value": "'json'"}, {"name": "case_data", "value": "{'code': 'test_add_org', 'demId': '需要更新', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}"}, {"name": "expect_data", "value": "{'message': '添加组织成功'}"}, {"name": "sql_data", "value": "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}"}, {"name": "sql_type", "value": "'select|delete'"}, {"name": "update_key", "value": "'demId'"}], "start": 1716277479315, "stop": 1716277479562, "uuid": "22b4c7d5-e7f1-43f8-be91-8c1ac1fe3c34", "historyId": "775a6ff6df9900840ea55e63958ed107", "testCaseId": "8c3ca9784f7a20f46f527b41c7204e5a", "fullName": "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "组织管理"}, {"name": "story", "value": "添加组织"}, {"name": "severity", "value": "高"}, {"name": "epic", "value": "BPM系统-老张"}, {"name": "parentSuite", "value": "test_case.test_mirZhang"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "DESKTOP-4FFIKGU"}, {"name": "thread", "value": "4400-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_mirZhang.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/03da959e-5ce9-4b10-bb97-baeae3a9a103-container.json

+{"uuid": "a3dbf9b3-6697-4746-94bb-f6d55518d229", "befores": [{"name": "url", "status": "passed", "start": 1716277476192, "stop": 1716277476192}], "start": 1716277476192, "stop": 1716277476445}
+{"uuid": "a3dbf9b3-6697-4746-94bb-f6d55518d229", "befores": [{"name": "url", "status": "passed", "start": 1716277476192, "stop": 1716277476192}], "start": 1716277476192, "stop": 1716277476445}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/05680149-6796-44ec-ad62-6ae85493a127-container.json

+{"uuid": "49180b26-01b2-424d-a639-e5ce208a7c75", "children": ["88ace585-dc6b-4e3a-9708-fcbfe05bdae7", "e338371a-e3b3-417b-bb2a-3b20b2ac8a92", "4072de5e-6227-4644-a2f0-f2eaed9e3ce4", "019dc1e1-87d3-41ce-a11d-c2bde8eb315a", "d3813785-cf39-46ec-8628-8a87da53a6a8", "50301355-695e-4676-99e4-a9d9e75fa3d1", "008b263b-d112-4182-9125-0de067a9d09d", "73e51308-8a66-4afa-ada5-5f74677e21c7", "64f0d0ee-77a7-4c42-9bc3-96e2993eb61d", "25d6e53b-b823-43f0-a916-f8645856c87d", "06e17ded-70be-4adb-a5db-34bd07ebaf38", "6fdd37ef-57fe-4c82-9fc7-4b73cdeddbf5", "f5d5dd7c-e705-4c33-845d-257bbe3d1108", "f62d1e5c-f86d-486a-ae5b-900ce8cf33f6", "1f6537c1-1923-4be6-82f2-da27bee57381", "919beb99-3877-46f2-83fa-ccaed2593128", "e7e80a77-759b-44d8-aa3f-a163356eb619"], "befores": [{"name": "req_fix", "status": "passed", "start": 1716277474024, "stop": 1716277474130}], "afters": [{"name": "req_fix::0", "status": "passed", "start": 1716277480108, "stop": 1716277480108}], "start": 1716277474024, "stop": 1716277480108}
+{"uuid": "49180b26-01b2-424d-a639-e5ce208a7c75", "children": ["88ace585-dc6b-4e3a-9708-fcbfe05bdae7", "e338371a-e3b3-417b-bb2a-3b20b2ac8a92", "4072de5e-6227-4644-a2f0-f2eaed9e3ce4", "019dc1e1-87d3-41ce-a11d-c2bde8eb315a", "d3813785-cf39-46ec-8628-8a87da53a6a8", "50301355-695e-4676-99e4-a9d9e75fa3d1", "008b263b-d112-4182-9125-0de067a9d09d", "73e51308-8a66-4afa-ada5-5f74677e21c7", "64f0d0ee-77a7-4c42-9bc3-96e2993eb61d", "25d6e53b-b823-43f0-a916-f8645856c87d", "06e17ded-70be-4adb-a5db-34bd07ebaf38", "6fdd37ef-57fe-4c82-9fc7-4b73cdeddbf5", "f5d5dd7c-e705-4c33-845d-257bbe3d1108", "f62d1e5c-f86d-486a-ae5b-900ce8cf33f6", "1f6537c1-1923-4be6-82f2-da27bee57381", "919beb99-3877-46f2-83fa-ccaed2593128", "e7e80a77-759b-44d8-aa3f-a163356eb619"], "befores": [{"name": "req_fix", "status": "passed", "start": 1716277474024, "stop": 1716277474130}], "afters": [{"name": "req_fix::0", "status": "passed", "start": 1716277480108, "stop": 1716277480108}], "start": 1716277474024, "stop": 1716277480108}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/05b508cc-193b-48e0-9044-7fb3e7185436-container.json

+{"uuid": "c615c0fe-97d5-4a0a-91d0-0ee6fb1052fc", "befores": [{"name": "api_name", "status": "passed", "start": 1716277476561, "stop": 1716277476561}], "start": 1716277476561, "stop": 1716277476649}
+{"uuid": "c615c0fe-97d5-4a0a-91d0-0ee6fb1052fc", "befores": [{"name": "api_name", "status": "passed", "start": 1716277476561, "stop": 1716277476561}], "start": 1716277476561, "stop": 1716277476649}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/066e3bd4-5f25-46cf-9958-24ccec2c9bc5-container.json

+{"uuid": "0761313f-2edb-4560-b2ec-15a46e88d4cf", "children": ["6a74726c-e49a-4ae7-a82e-c3c80884d1f5", "22b4c7d5-e7f1-43f8-be91-8c1ac1fe3c34", "da02e592-b09d-493d-9301-457b499905ad", "c7737e9d-cc0a-4514-860a-62c1fb6b0844", "9a6ba79a-6000-44c4-8e47-b292b8ae10c1", "a8a1c3fb-e4ad-49cd-bac0-671eba3a20a3"], "befores": [{"name": "db_fix", "status": "passed", "start": 1716277478901, "stop": 1716277479118}], "afters": [{"name": "db_fix::0", "status": "passed", "start": 1716277480097, "stop": 1716277480098}], "start": 1716277478901, "stop": 1716277480098}
+{"uuid": "0761313f-2edb-4560-b2ec-15a46e88d4cf", "children": ["6a74726c-e49a-4ae7-a82e-c3c80884d1f5", "22b4c7d5-e7f1-43f8-be91-8c1ac1fe3c34", "da02e592-b09d-493d-9301-457b499905ad", "c7737e9d-cc0a-4514-860a-62c1fb6b0844", "9a6ba79a-6000-44c4-8e47-b292b8ae10c1", "a8a1c3fb-e4ad-49cd-bac0-671eba3a20a3"], "befores": [{"name": "db_fix", "status": "passed", "start": 1716277478901, "stop": 1716277479118}], "afters": [{"name": "db_fix::0", "status": "passed", "start": 1716277480097, "stop": 1716277480098}], "start": 1716277478901, "stop": 1716277480098}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/089e5c41-bda6-4700-8afd-45ccd35c1ecb-container.json

+{"uuid": "83b44a25-dccc-4569-b55a-3d408cdad490", "befores": [{"name": "url", "status": "passed", "start": 1716277474796, "stop": 1716277474796}], "start": 1716277474796, "stop": 1716277474905}
+{"uuid": "83b44a25-dccc-4569-b55a-3d408cdad490", "befores": [{"name": "url", "status": "passed", "start": 1716277474796, "stop": 1716277474796}], "start": 1716277474796, "stop": 1716277474905}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/08fc4e3e-4d71-47ec-877d-4d3181c8b69e-container.json

+{"uuid": "0f281764-6cbb-4b2a-8ec6-ebb1e4cc5527", "befores": [{"name": "module_name", "status": "passed", "start": 1716277479309, "stop": 1716277479309}], "start": 1716277479309, "stop": 1716277479597}
+{"uuid": "0f281764-6cbb-4b2a-8ec6-ebb1e4cc5527", "befores": [{"name": "module_name", "status": "passed", "start": 1716277479309, "stop": 1716277479309}], "start": 1716277479309, "stop": 1716277479597}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/09173982-ca2a-4d42-9f3b-be896a3cb09b-container.json

+{"uuid": "95e4224c-091c-474f-b1dd-1de5a4663163", "befores": [{"name": "method", "status": "passed", "start": 1716277476562, "stop": 1716277476562}], "start": 1716277476562, "stop": 1716277476645}
+{"uuid": "95e4224c-091c-474f-b1dd-1de5a4663163", "befores": [{"name": "method", "status": "passed", "start": 1716277476562, "stop": 1716277476562}], "start": 1716277476562, "stop": 1716277476645}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/09ff0bf7-5a5c-474a-b1b5-243d48cfe2bc-container.json

+{"uuid": "2057537e-8b20-4f20-84eb-ce4ed029cdc8", "befores": [{"name": "sql_type", "status": "passed", "start": 1716277474797, "stop": 1716277474797}], "start": 1716277474797, "stop": 1716277474898}
+{"uuid": "2057537e-8b20-4f20-84eb-ce4ed029cdc8", "befores": [{"name": "sql_type", "status": "passed", "start": 1716277474797, "stop": 1716277474797}], "start": 1716277474797, "stop": 1716277474898}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/0a0df309-d44f-449f-b27b-91577c9fcd58-container.json

+{"uuid": "1e16fa6e-80ca-4895-bcf7-f02bf08bfeee", "befores": [{"name": "expect_data", "status": "passed", "start": 1716277479923, "stop": 1716277479923}], "start": 1716277479923, "stop": 1716277480069}
+{"uuid": "1e16fa6e-80ca-4895-bcf7-f02bf08bfeee", "befores": [{"name": "expect_data", "status": "passed", "start": 1716277479923, "stop": 1716277479923}], "start": 1716277479923, "stop": 1716277480069}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/0aea117d-d875-4fc2-9472-c086c3b68d8c-container.json

+{"uuid": "092cfddb-3f5f-419e-bbff-ac88c3be6246", "befores": [{"name": "case_title", "status": "passed", "start": 1716277476011, "stop": 1716277476011}], "start": 1716277476011, "stop": 1716277476166}
+{"uuid": "092cfddb-3f5f-419e-bbff-ac88c3be6246", "befores": [{"name": "case_title", "status": "passed", "start": 1716277476011, "stop": 1716277476011}], "start": 1716277476011, "stop": 1716277476166}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/0b006032-0b43-48db-a776-2d915e640262-attachment.txt

+断言
+断言

InterfaceAutoTest/report/json/BPM接口测试.json/0b9f44a8-20b2-4aa8-a3c3-8ee54455c42c-container.json

+{"uuid": "fccaeded-4d47-40b6-be74-342e0ac1f67f", "befores": [{"name": "sql_data", "status": "passed", "start": 1716277476473, "stop": 1716277476473}], "start": 1716277476473, "stop": 1716277476536}
+{"uuid": "fccaeded-4d47-40b6-be74-342e0ac1f67f", "befores": [{"name": "sql_data", "status": "passed", "start": 1716277476473, "stop": 1716277476473}], "start": 1716277476473, "stop": 1716277476536}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/0c676bf1-46c7-4b8e-9e6f-9224856502e6-container.json

+{"uuid": "35461153-bd4d-48e4-84fa-bac68c2ba40a", "befores": [{"name": "module_name", "status": "passed", "start": 1716277474795, "stop": 1716277474795}], "start": 1716277474795, "stop": 1716277474915}
+{"uuid": "35461153-bd4d-48e4-84fa-bac68c2ba40a", "befores": [{"name": "module_name", "status": "passed", "start": 1716277474795, "stop": 1716277474795}], "start": 1716277474795, "stop": 1716277474915}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/0d4f85bc-626a-42a4-b9bd-f7047efe2ca8-result.json

+{"name": "登录--前置", "status": "passed", "attachments": [{"name": "stdout", "source": "598cd417-2d03-43c6-8a86-5bd46cd128a9-attachment.txt", "type": "text/plain"}], "start": 1716277477056, "stop": 1716277477165, "uuid": "8625242c-eb66-463a-8002-86e3be4cb5f5", "historyId": "b3ea99bce5fbf89dc61e67ffc74d2796", "testCaseId": "b3ea99bce5fbf89dc61e67ffc74d2796", "fullName": "test_case.test_dependency.test_dependency#test_login", "labels": [{"name": "story", "value": "登录系统"}, {"name": "epic", "value": "BPM-场景测试"}, {"name": "feature", "value": "认证接口"}, {"name": "tag", "value": "dependency"}, {"name": "parentSuite", "value": "test_case.test_dependency"}, {"name": "suite", "value": "test_dependency"}, {"name": "host", "value": "DESKTOP-4FFIKGU"}, {"name": "thread", "value": "4400-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_dependency.test_dependency"}]}
+{"name": "登录--前置", "status": "passed", "attachments": [{"name": "stdout", "source": "598cd417-2d03-43c6-8a86-5bd46cd128a9-attachment.txt", "type": "text/plain"}], "start": 1716277477056, "stop": 1716277477165, "uuid": "8625242c-eb66-463a-8002-86e3be4cb5f5", "historyId": "b3ea99bce5fbf89dc61e67ffc74d2796", "testCaseId": "b3ea99bce5fbf89dc61e67ffc74d2796", "fullName": "test_case.test_dependency.test_dependency#test_login", "labels": [{"name": "story", "value": "登录系统"}, {"name": "epic", "value": "BPM-场景测试"}, {"name": "feature", "value": "认证接口"}, {"name": "tag", "value": "dependency"}, {"name": "parentSuite", "value": "test_case.test_dependency"}, {"name": "suite", "value": "test_dependency"}, {"name": "host", "value": "DESKTOP-4FFIKGU"}, {"name": "thread", "value": "4400-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_dependency.test_dependency"}]}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/0ea7fb6d-ea6e-40f2-a8cd-f47f4102cf79-result.json

+{"name": "正向用例", "status": "passed", "attachments": [{"name": "log", "source": "75bd40ef-eb21-4c8c-b23c-4f1834f90dc5-attachment.txt", "type": "text/plain"}, {"name": "stdout", "source": "498f92e5-5971-4d3c-abb3-2e11c549bee5-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'组织管理'"}, {"name": "api_name", "value": "'保存组织参数'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'post'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/org/v1/orgParam/saveOrgParams'"}, {"name": "mime", "value": "'query|json'"}, {"name": "case_data", "value": "{'query': {'orgCode': 'test_add_org'}, 'body': [{'alias': 'sz', 'value': 100}, {'alias': 'kc', 'value': '语文课'}]}"}, {"name": "expect_data", "value": "{'state': True, 'message': '保存组织参数成功！', 'value': ''}"}, {"name": "sql_data", "value": "None"}, {"name": "sql_type", "value": "None"}, {"name": "update_key", "value": "None"}], "start": 1716277479716, "stop": 1716277479785, "uuid": "c7737e9d-cc0a-4514-860a-62c1fb6b0844", "historyId": "f523c6add46569d79b9a33cc763be891", "testCaseId": "8c3ca9784f7a20f46f527b41c7204e5a", "fullName": "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "组织管理"}, {"name": "story", "value": "保存组织参数"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-老张"}, {"name": "parentSuite", "value": "test_case.test_mirZhang"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "DESKTOP-4FFIKGU"}, {"name": "thread", "value": "4400-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_mirZhang.test_bpm"}]}
+{"name": "正向用例", "status": "passed", "attachments": [{"name": "log", "source": "75bd40ef-eb21-4c8c-b23c-4f1834f90dc5-attachment.txt", "type": "text/plain"}, {"name": "stdout", "source": "498f92e5-5971-4d3c-abb3-2e11c549bee5-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'组织管理'"}, {"name": "api_name", "value": "'保存组织参数'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'post'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/org/v1/orgParam/saveOrgParams'"}, {"name": "mime", "value": "'query|json'"}, {"name": "case_data", "value": "{'query': {'orgCode': 'test_add_org'}, 'body': [{'alias': 'sz', 'value': 100}, {'alias': 'kc', 'value': '语文课'}]}"}, {"name": "expect_data", "value": "{'state': True, 'message': '保存组织参数成功！', 'value': ''}"}, {"name": "sql_data", "value": "None"}, {"name": "sql_type", "value": "None"}, {"name": "update_key", "value": "None"}], "start": 1716277479716, "stop": 1716277479785, "uuid": "c7737e9d-cc0a-4514-860a-62c1fb6b0844", "historyId": "f523c6add46569d79b9a33cc763be891", "testCaseId": "8c3ca9784f7a20f46f527b41c7204e5a", "fullName": "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "组织管理"}, {"name": "story", "value": "保存组织参数"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-老张"}, {"name": "parentSuite", "value": "test_case.test_mirZhang"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "DESKTOP-4FFIKGU"}, {"name": "thread", "value": "4400-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_mirZhang.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/0f8e6da5-b02c-4618-938c-e27052749865-container.json

+{"uuid": "9db0d82c-f92f-466b-a46c-601cc8aa40cb", "befores": [{"name": "expect_data", "status": "passed", "start": 1716277474545, "stop": 1716277474545}], "start": 1716277474545, "stop": 1716277474649}
+{"uuid": "9db0d82c-f92f-466b-a46c-601cc8aa40cb", "befores": [{"name": "expect_data", "status": "passed", "start": 1716277474545, "stop": 1716277474545}], "start": 1716277474545, "stop": 1716277474649}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/0f988812-f8c4-49dc-b758-7819e6e37322-attachment.txt

+断言
+断言

InterfaceAutoTest/report/json/BPM接口测试.json/103e779a-6005-49fa-b879-353af4d7445f-container.json

+{"uuid": "76c9e8ca-cb66-4ce5-b76e-bf48bd1b9cfb", "befores": [{"name": "case_data", "status": "passed", "start": 1716277476472, "stop": 1716277476473}], "start": 1716277476472, "stop": 1716277476540}
+{"uuid": "76c9e8ca-cb66-4ce5-b76e-bf48bd1b9cfb", "befores": [{"name": "case_data", "status": "passed", "start": 1716277476472, "stop": 1716277476473}], "start": 1716277476472, "stop": 1716277476540}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/109d8b76-c140-4d94-aa52-7138768c428a-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '删除维度成功' == '删除维度成功！'\n  - 删除维度成功！\n  ?       -\n  + 删除维度成功", "trace": "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000027C56124F80>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000027C563A7C20>, db_fix = <InterfaceAutoTest.common.db.DB object at 0x0000027C564B5580>\nmodule_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例', case_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'\nmime = 'query', case_data = {'ids': '1792823812232855552'}, expect_data = {'message': '删除维度成功'}, sql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'\nsql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000027C56124F80>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000027C563A7C20>, db_fix = <InterfaceAutoTest.common.db.DB object at 0x0000027C564B5580>\nmodule_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例', case_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'\nmime = 'query', case_data = {'ids': '1792823812232855552'}, expect_data = {'message': '删除维度成功'}, sql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'\nsql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == '删除维度成功！'\nE                 - 删除维度成功！\nE                 ?       -\nE                 + 删除维度成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "15fc0009-c0ba-4013-b61e-d659a9ff8335-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'维度管理'"}, {"name": "api_name", "value": "'根据维度编码删除维度'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'DELETE'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'"}, {"name": "mime", "value": "'query'"}, {"name": "case_data", "value": "{'ids': '需要更新'}"}, {"name": "expect_data", "value": "{'message': '删除维度成功'}"}, {"name": "sql_data", "value": "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"}, {"name": "sql_type", "value": "'select'"}, {"name": "update_key", "value": "'ids'"}], "start": 1716277479924, "stop": 1716277480024, "uuid": "a8a1c3fb-e4ad-49cd-bac0-671eba3a20a3", "historyId": "8a01ff0270b78581305f47bac61f6220", "testCaseId": "8c3ca9784f7a20f46f527b41c7204e5a", "fullName": "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "维度管理"}, {"name": "story", "value": "根据维度编码删除维度"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-老张"}, {"name": "parentSuite", "value": "test_case.test_mirZhang"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "DESKTOP-4FFIKGU"}, {"name": "thread", "value": "4400-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_mirZhang.test_bpm"}]}
+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '删除维度成功' == '删除维度成功！'\n  - 删除维度成功！\n  ?       -\n  + 删除维度成功", "trace": "self = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000027C56124F80>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000027C563A7C20>, db_fix = <InterfaceAutoTest.common.db.DB object at 0x0000027C564B5580>\nmodule_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例', case_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'\nmime = 'query', case_data = {'ids': '1792823812232855552'}, expect_data = {'message': '删除维度成功'}, sql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'\nsql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_mirZhang\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_mirZhang.test_bpm.TestBPM object at 0x0000027C56124F80>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000027C563A7C20>, db_fix = <InterfaceAutoTest.common.db.DB object at 0x0000027C564B5580>\nmodule_name = '维度管理', api_name = '根据维度编码删除维度', case_title = '正向用例', case_level = '中', method = 'DELETE', url = 'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'\nmime = 'query', case_data = {'ids': '1792823812232855552'}, expect_data = {'message': '删除维度成功'}, sql_data = 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'\nsql_type = 'select', update_key = 'ids'\n\n    @allure.epic(\"BPM系统-老张\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '删除维度成功' == '删除维度成功！'\nE                 - 删除维度成功！\nE                 ?       -\nE                 + 删除维度成功\n\ntest_case\\test_mirZhang\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "15fc0009-c0ba-4013-b61e-d659a9ff8335-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'维度管理'"}, {"name": "api_name", "value": "'根据维度编码删除维度'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'DELETE'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/demension/v1/dem/deleteDemByIds'"}, {"name": "mime", "value": "'query'"}, {"name": "case_data", "value": "{'ids': '需要更新'}"}, {"name": "expect_data", "value": "{'message': '删除维度成功'}"}, {"name": "sql_data", "value": "'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'"}, {"name": "sql_type", "value": "'select'"}, {"name": "update_key", "value": "'ids'"}], "start": 1716277479924, "stop": 1716277480024, "uuid": "a8a1c3fb-e4ad-49cd-bac0-671eba3a20a3", "historyId": "8a01ff0270b78581305f47bac61f6220", "testCaseId": "8c3ca9784f7a20f46f527b41c7204e5a", "fullName": "test_case.test_mirZhang.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "维度管理"}, {"name": "story", "value": "根据维度编码删除维度"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-老张"}, {"name": "parentSuite", "value": "test_case.test_mirZhang"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "DESKTOP-4FFIKGU"}, {"name": "thread", "value": "4400-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_mirZhang.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/11049d9b-de61-47d9-907b-919d5c331a10-container.json

+{"uuid": "fed5487d-6d5f-4bdb-95bd-e8a39b6d208e", "befores": [{"name": "api_name", "status": "passed", "start": 1716277479922, "stop": 1716277479922}], "start": 1716277479922, "stop": 1716277480092}
+{"uuid": "fed5487d-6d5f-4bdb-95bd-e8a39b6d208e", "befores": [{"name": "api_name", "status": "passed", "start": 1716277479922, "stop": 1716277479922}], "start": 1716277479922, "stop": 1716277480092}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/112265fe-a67a-4583-b474-a4374f652cd3-container.json

+{"uuid": "0405a9d8-07f3-42f7-9a85-d895384beec4", "befores": [{"name": "case_level", "status": "passed", "start": 1716277475432, "stop": 1716277475432}], "start": 1716277475432, "stop": 1716277475543}
+{"uuid": "0405a9d8-07f3-42f7-9a85-d895384beec4", "befores": [{"name": "case_level", "status": "passed", "start": 1716277475432, "stop": 1716277475432}], "start": 1716277475432, "stop": 1716277475543}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/11b536de-566b-485b-9854-085bc93f46d3-container.json

+{"uuid": "77104501-6032-4e33-8ad1-dddbdb68850c", "befores": [{"name": "expect_data", "status": "passed", "start": 1716277476660, "stop": 1716277476660}], "start": 1716277476660, "stop": 1716277476735}
+{"uuid": "77104501-6032-4e33-8ad1-dddbdb68850c", "befores": [{"name": "expect_data", "status": "passed", "start": 1716277476660, "stop": 1716277476660}], "start": 1716277476660, "stop": 1716277476735}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/12b1f948-9533-4119-8acb-5dd90d6afd8e-container.json

+{"uuid": "7253fcfa-e4f8-4224-813f-d2a55715179f", "befores": [{"name": "case_data", "status": "passed", "start": 1716277479923, "stop": 1716277479923}], "start": 1716277479923, "stop": 1716277480075}
+{"uuid": "7253fcfa-e4f8-4224-813f-d2a55715179f", "befores": [{"name": "case_data", "status": "passed", "start": 1716277479923, "stop": 1716277479923}], "start": 1716277479923, "stop": 1716277480075}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/1455d1f5-4821-42d2-bce6-9f8313c89df4-container.json

+{"uuid": "8212e599-b19b-47a6-b38f-72eb75acdbb4", "befores": [{"name": "api_name", "status": "passed", "start": 1716277475294, "stop": 1716277475294}], "start": 1716277475294, "stop": 1716277475423}
+{"uuid": "8212e599-b19b-47a6-b38f-72eb75acdbb4", "befores": [{"name": "api_name", "status": "passed", "start": 1716277475294, "stop": 1716277475294}], "start": 1716277475294, "stop": 1716277475423}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/149668f2-f97c-4cec-bdc1-71ae2d402653-attachment.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'orgCode': 'test_add_org', 'accounts': 'admin'}, 期望数据为:{'state': True, 'message': '加入成功', 'value': ''}, 服务器返回的数据为：{"state":true,"message":"加入成功","value":""}
+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'orgCode': 'test_add_org', 'accounts': 'admin'}, 期望数据为:{'state': True, 'message': '加入成功', 'value': ''}, 服务器返回的数据为：{"state":true,"message":"加入成功","value":""}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/15bb1665-e628-432b-9737-4de99ef439bf-container.json

+{"uuid": "52576beb-9c7a-4588-aab4-84f5ccb8fb6d", "befores": [{"name": "mime", "status": "passed", "start": 1716277474925, "stop": 1716277474925}], "start": 1716277474925, "stop": 1716277475031}
+{"uuid": "52576beb-9c7a-4588-aab4-84f5ccb8fb6d", "befores": [{"name": "mime", "status": "passed", "start": 1716277474925, "stop": 1716277474925}], "start": 1716277474925, "stop": 1716277475031}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/15fc0009-c0ba-4013-b61e-d659a9ff8335-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792823812232855552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792823812232855552'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/16410d4e-fad1-44ab-97e9-850e42d4f739-container.json

+{"uuid": "92587971-4b64-4190-8bdc-cc4f49234303", "befores": [{"name": "case_title", "status": "passed", "start": 1716277475432, "stop": 1716277475432}], "start": 1716277475432, "stop": 1716277475545}
+{"uuid": "92587971-4b64-4190-8bdc-cc4f49234303", "befores": [{"name": "case_title", "status": "passed", "start": 1716277475432, "stop": 1716277475432}], "start": 1716277475432, "stop": 1716277475545}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/1769218c-bd16-4118-b507-603f5589ac2a-container.json

+{"uuid": "75ef2284-313f-4b4a-8211-6f7047005af4", "befores": [{"name": "mime", "status": "passed", "start": 1716277475433, "stop": 1716277475433}], "start": 1716277475433, "stop": 1716277475536}
+{"uuid": "75ef2284-313f-4b4a-8211-6f7047005af4", "befores": [{"name": "mime", "status": "passed", "start": 1716277475433, "stop": 1716277475433}], "start": 1716277475433, "stop": 1716277475536}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/17fd6fd9-425b-45ec-8da0-185e447039b5-container.json

+{"uuid": "a4c799e0-9533-49da-9efc-eb4894d24175", "befores": [{"name": "api_name", "status": "passed", "start": 1716277474334, "stop": 1716277474335}], "start": 1716277474334, "stop": 1716277474434}
+{"uuid": "a4c799e0-9533-49da-9efc-eb4894d24175", "befores": [{"name": "api_name", "status": "passed", "start": 1716277474334, "stop": 1716277474335}], "start": 1716277474334, "stop": 1716277474434}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/183e004b-d9f9-47ce-9624-26af89fafa32-container.json

+{"uuid": "2da0e4dc-b2fe-4f80-bb24-2f132b20acab", "befores": [{"name": "mime", "status": "passed", "start": 1716277479714, "stop": 1716277479714}], "start": 1716277479714, "stop": 1716277479801}
+{"uuid": "2da0e4dc-b2fe-4f80-bb24-2f132b20acab", "befores": [{"name": "mime", "status": "passed", "start": 1716277479714, "stop": 1716277479714}], "start": 1716277479714, "stop": 1716277479801}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/1b6de457-f84a-491b-a808-ee5f7ec25227-container.json

+{"uuid": "5c871fe0-a768-45f3-83a0-93fd29a9e1d6", "befores": [{"name": "api_name", "status": "passed", "start": 1716277476011, "stop": 1716277476011}], "start": 1716277476011, "stop": 1716277476168}
+{"uuid": "5c871fe0-a768-45f3-83a0-93fd29a9e1d6", "befores": [{"name": "api_name", "status": "passed", "start": 1716277476011, "stop": 1716277476011}], "start": 1716277476011, "stop": 1716277476168}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/1c0db6ee-97f7-4d3f-b143-41723da7fa13-container.json

+{"uuid": "4a6efec7-ab9c-4f7e-a8ef-02010c38a140", "befores": [{"name": "sql_type", "status": "passed", "start": 1716277476562, "stop": 1716277476562}], "start": 1716277476562, "stop": 1716277476632}
+{"uuid": "4a6efec7-ab9c-4f7e-a8ef-02010c38a140", "befores": [{"name": "sql_type", "status": "passed", "start": 1716277476562, "stop": 1716277476562}], "start": 1716277476562, "stop": 1716277476632}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/1c72de82-6245-46e0-935a-46d7debd9cc4-container.json

+{"uuid": "e62aafbb-4168-4fce-bf2c-8e8475fcb175", "befores": [{"name": "case_title", "status": "passed", "start": 1716277474443, "stop": 1716277474443}], "start": 1716277474443, "stop": 1716277474523}
+{"uuid": "e62aafbb-4168-4fce-bf2c-8e8475fcb175", "befores": [{"name": "case_title", "status": "passed", "start": 1716277474443, "stop": 1716277474443}], "start": 1716277474443, "stop": 1716277474523}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/1da6770b-15e7-41c9-89c4-033910acb9fb-container.json

+{"uuid": "cb6f825b-4170-476b-9ccb-a05a301ebd02", "befores": [{"name": "url", "status": "passed", "start": 1716277476562, "stop": 1716277476562}], "start": 1716277476562, "stop": 1716277476643}
+{"uuid": "cb6f825b-4170-476b-9ccb-a05a301ebd02", "befores": [{"name": "url", "status": "passed", "start": 1716277476562, "stop": 1716277476562}], "start": 1716277476562, "stop": 1716277476643}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/1dd9820b-11f6-4491-9413-5d95418ee95f-container.json

+{"uuid": "a00bc0ec-7558-4098-8d93-6ef51925f21e", "befores": [{"name": "case_title", "status": "passed", "start": 1716277479713, "stop": 1716277479713}], "start": 1716277479713, "stop": 1716277479811}
+{"uuid": "a00bc0ec-7558-4098-8d93-6ef51925f21e", "befores": [{"name": "case_title", "status": "passed", "start": 1716277479713, "stop": 1716277479713}], "start": 1716277479713, "stop": 1716277479811}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/1e39c1ff-ec28-4c3a-a450-e4101c1b44b8-container.json

+{"uuid": "ec117ebd-e7f8-4a61-9db6-8c01fcffdb28", "befores": [{"name": "sql_type", "status": "passed", "start": 1716277476193, "stop": 1716277476193}], "start": 1716277476193, "stop": 1716277476432}
+{"uuid": "ec117ebd-e7f8-4a61-9db6-8c01fcffdb28", "befores": [{"name": "sql_type", "status": "passed", "start": 1716277476193, "stop": 1716277476193}], "start": 1716277476193, "stop": 1716277476432}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/1e79a23d-eff7-459a-8d41-725c0bd426de-container.json

+{"uuid": "8051b3a1-3d06-426c-8ac6-acbfb42e65ab", "befores": [{"name": "sql_type", "status": "passed", "start": 1716277475179, "stop": 1716277475179}], "start": 1716277475179, "stop": 1716277475273}
+{"uuid": "8051b3a1-3d06-426c-8ac6-acbfb42e65ab", "befores": [{"name": "sql_type", "status": "passed", "start": 1716277475179, "stop": 1716277475179}], "start": 1716277475179, "stop": 1716277475273}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/1ef41e02-d548-4fdf-b4db-156e8b2fe9f1-container.json

+{"uuid": "3195232c-db58-4d92-b6f8-b5fd04a83d7b", "befores": [{"name": "api_name", "status": "passed", "start": 1716277474795, "stop": 1716277474795}], "start": 1716277474795, "stop": 1716277474914}
+{"uuid": "3195232c-db58-4d92-b6f8-b5fd04a83d7b", "befores": [{"name": "api_name", "status": "passed", "start": 1716277474795, "stop": 1716277474795}], "start": 1716277474795, "stop": 1716277474914}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/1f728ed4-eaf2-41f0-a365-84da40bf0fd2-container.json

+{"uuid": "ddba9360-bf1c-432c-906d-4ed483d8e75e", "befores": [{"name": "method", "status": "passed", "start": 1716277475559, "stop": 1716277475559}], "start": 1716277475559, "stop": 1716277475998}
+{"uuid": "ddba9360-bf1c-432c-906d-4ed483d8e75e", "befores": [{"name": "method", "status": "passed", "start": 1716277475559, "stop": 1716277475559}], "start": 1716277475559, "stop": 1716277475998}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/20083226-a054-4097-a98a-74cb76beda90-container.json

+{"uuid": "8226918b-e049-408a-b037-51cd15f2bace", "befores": [{"name": "url", "status": "passed", "start": 1716277479922, "stop": 1716277479922}], "start": 1716277479922, "stop": 1716277480082}
+{"uuid": "8226918b-e049-408a-b037-51cd15f2bace", "befores": [{"name": "url", "status": "passed", "start": 1716277479922, "stop": 1716277479922}], "start": 1716277479922, "stop": 1716277480082}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/20506b88-73d5-42cb-90b4-503ee276f3da-container.json

+{"uuid": "4d099fcc-50bf-4497-b986-f4a603ab0ae0", "befores": [{"name": "expect_data", "status": "passed", "start": 1716277476562, "stop": 1716277476562}], "start": 1716277476562, "stop": 1716277476637}
+{"uuid": "4d099fcc-50bf-4497-b986-f4a603ab0ae0", "befores": [{"name": "expect_data", "status": "passed", "start": 1716277476562, "stop": 1716277476562}], "start": 1716277476562, "stop": 1716277476637}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/20744415-4d77-4f3c-8d96-86e82bb36d9a-container.json

+{"uuid": "d8c509b4-d3b5-47a7-ac1c-f1cb858ac84f", "befores": [{"name": "mime", "status": "passed", "start": 1716277474444, "stop": 1716277474444}], "start": 1716277474444, "stop": 1716277474517}
+{"uuid": "d8c509b4-d3b5-47a7-ac1c-f1cb858ac84f", "befores": [{"name": "mime", "status": "passed", "start": 1716277474444, "stop": 1716277474444}], "start": 1716277474444, "stop": 1716277474517}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/20883927-78df-4bcd-b9ba-f3bb7bbe5f95-container.json

+{"uuid": "48c9e6f9-d312-499e-9c28-1c1b322a5f3c", "befores": [{"name": "case_title", "status": "passed", "start": 1716277479625, "stop": 1716277479626}], "start": 1716277479625, "stop": 1716277479703}
+{"uuid": "48c9e6f9-d312-499e-9c28-1c1b322a5f3c", "befores": [{"name": "case_title", "status": "passed", "start": 1716277479625, "stop": 1716277479626}], "start": 1716277479625, "stop": 1716277479703}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/20e110cd-d836-488e-b674-c8c416f12d25-container.json

+{"uuid": "ad99e883-c6d0-4985-aaa8-3d4cc2f07a20", "befores": [{"name": "method", "status": "passed", "start": 1716277474796, "stop": 1716277474796}], "start": 1716277474796, "stop": 1716277474908}
+{"uuid": "ad99e883-c6d0-4985-aaa8-3d4cc2f07a20", "befores": [{"name": "method", "status": "passed", "start": 1716277474796, "stop": 1716277474796}], "start": 1716277474796, "stop": 1716277474908}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/227f8d3e-441c-4d53-a02e-60caeda6b05c-container.json

+{"uuid": "2dc7e837-8d3d-47c8-b06b-651d0b4e0c05", "befores": [{"name": "api_name", "status": "passed", "start": 1716277474924, "stop": 1716277474924}], "start": 1716277474924, "stop": 1716277475038}
+{"uuid": "2dc7e837-8d3d-47c8-b06b-651d0b4e0c05", "befores": [{"name": "api_name", "status": "passed", "start": 1716277474924, "stop": 1716277474924}], "start": 1716277474924, "stop": 1716277475038}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/237c4dc9-8baa-462c-9e34-5e4c68f464b4-container.json

+{"uuid": "1486026a-5ac2-4904-bc01-969ed7dd149f", "befores": [{"name": "case_title", "status": "passed", "start": 1716277479119, "stop": 1716277479119}], "start": 1716277479119, "stop": 1716277479292}
+{"uuid": "1486026a-5ac2-4904-bc01-969ed7dd149f", "befores": [{"name": "case_title", "status": "passed", "start": 1716277479119, "stop": 1716277479119}], "start": 1716277479119, "stop": 1716277479292}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/23b6fa61-6902-41f8-ad17-a49a9d6b3a7e-container.json

+{"uuid": "227e5ad9-3883-4191-a314-6c81cf80c81b", "befores": [{"name": "case_level", "status": "passed", "start": 1716277479829, "stop": 1716277479829}], "start": 1716277479829, "stop": 1716277479908}
+{"uuid": "227e5ad9-3883-4191-a314-6c81cf80c81b", "befores": [{"name": "case_level", "status": "passed", "start": 1716277479829, "stop": 1716277479829}], "start": 1716277479829, "stop": 1716277479908}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/241abc27-5f49-46eb-a141-dea4624f4301-attachment.txt

+断言
+断言

InterfaceAutoTest/report/json/BPM接口测试.json/258e4237-90b0-4ef1-bf9f-4cdc68675f90-container.json

+{"uuid": "c40ee061-155f-4823-94d2-84fdedb31829", "befores": [{"name": "url", "status": "passed", "start": 1716277479120, "stop": 1716277479120}], "start": 1716277479120, "stop": 1716277479286}
+{"uuid": "c40ee061-155f-4823-94d2-84fdedb31829", "befores": [{"name": "url", "status": "passed", "start": 1716277479120, "stop": 1716277479120}], "start": 1716277479120, "stop": 1716277479286}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/26533669-c55e-4806-9a18-ccb9313306e5-container.json

+{"uuid": "d77c134a-66d8-451f-9967-cee347885e24", "befores": [{"name": "case_title", "status": "passed", "start": 1716277476659, "stop": 1716277476659}], "start": 1716277476659, "stop": 1716277476759}
+{"uuid": "d77c134a-66d8-451f-9967-cee347885e24", "befores": [{"name": "case_title", "status": "passed", "start": 1716277476659, "stop": 1716277476659}], "start": 1716277476659, "stop": 1716277476759}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/27b0e157-47b5-4dfa-9a7a-525560f2e7d2-container.json

+{"uuid": "be8e5ce0-f1d8-4175-99f5-54a4910ac9e6", "befores": [{"name": "url", "status": "passed", "start": 1716277474444, "stop": 1716277474444}], "start": 1716277474444, "stop": 1716277474518}
+{"uuid": "be8e5ce0-f1d8-4175-99f5-54a4910ac9e6", "befores": [{"name": "url", "status": "passed", "start": 1716277474444, "stop": 1716277474444}], "start": 1716277474444, "stop": 1716277474518}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/29b4b1bd-e1f6-40ec-8ed9-0ef451fcdad1-result.json

+{"name": "反向用例-用户名正确,密码过长", "status": "passed", "attachments": [{"name": "log", "source": "c9ea98c4-3a47-4320-822e-f0c9280ad26f-attachment.txt", "type": "text/plain"}, {"name": "stdout", "source": "be5ee844-bf70-4f94-8649-ccab7da54d3a-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'认证接口'"}, {"name": "api_name", "value": "'登录系统'"}, {"name": "case_title", "value": "'反向用例-用户名正确,密码过长'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/auth'"}, {"name": "mime", "value": "'application/json'"}, {"name": "case_data", "value": "{'username': 'admin', 'password': 'MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2'}"}, {"name": "expect_data", "value": "{'message': '账号或密码错误'}"}, {"name": "sql_data", "value": "None"}, {"name": "sql_type", "value": "None"}, {"name": "update_key", "value": "None"}], "start": 1716277474547, "stop": 1716277474643, "uuid": "4072de5e-6227-4644-a2f0-f2eaed9e3ce4", "historyId": "37bde76add67e3f73e804e1ff293bbd9", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "认证接口"}, {"name": "story", "value": "登录系统"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "DESKTOP-4FFIKGU"}, {"name": "thread", "value": "4400-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
+{"name": "反向用例-用户名正确,密码过长", "status": "passed", "attachments": [{"name": "log", "source": "c9ea98c4-3a47-4320-822e-f0c9280ad26f-attachment.txt", "type": "text/plain"}, {"name": "stdout", "source": "be5ee844-bf70-4f94-8649-ccab7da54d3a-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'认证接口'"}, {"name": "api_name", "value": "'登录系统'"}, {"name": "case_title", "value": "'反向用例-用户名正确,密码过长'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/auth'"}, {"name": "mime", "value": "'application/json'"}, {"name": "case_data", "value": "{'username': 'admin', 'password': 'MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2'}"}, {"name": "expect_data", "value": "{'message': '账号或密码错误'}"}, {"name": "sql_data", "value": "None"}, {"name": "sql_type", "value": "None"}, {"name": "update_key", "value": "None"}], "start": 1716277474547, "stop": 1716277474643, "uuid": "4072de5e-6227-4644-a2f0-f2eaed9e3ce4", "historyId": "37bde76add67e3f73e804e1ff293bbd9", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "认证接口"}, {"name": "story", "value": "登录系统"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "DESKTOP-4FFIKGU"}, {"name": "thread", "value": "4400-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/2a4bf4e2-b220-4ca3-9232-c603371271b2-container.json

+{"uuid": "fe27ad56-033a-4a08-966c-3bd431dd9af7", "befores": [{"name": "case_data", "status": "passed", "start": 1716277475179, "stop": 1716277475179}], "start": 1716277475179, "stop": 1716277475277}
+{"uuid": "fe27ad56-033a-4a08-966c-3bd431dd9af7", "befores": [{"name": "case_data", "status": "passed", "start": 1716277475179, "stop": 1716277475179}], "start": 1716277475179, "stop": 1716277475277}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/2ea18e66-ab02-45f7-a922-0551d7fd1fa8-container.json

+{"uuid": "d8478efa-4a17-4943-a902-756001ae3c92", "befores": [{"name": "module_name", "status": "passed", "start": 1716277474542, "stop": 1716277474542}], "start": 1716277474541, "stop": 1716277474659}
+{"uuid": "d8478efa-4a17-4943-a902-756001ae3c92", "befores": [{"name": "module_name", "status": "passed", "start": 1716277474542, "stop": 1716277474542}], "start": 1716277474541, "stop": 1716277474659}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/2f06da78-2cb6-482e-b632-9eff26e5f71f-container.json

+{"uuid": "4309e218-d16d-4522-90d7-7737416e0891", "befores": [{"name": "update_key", "status": "passed", "start": 1716277476660, "stop": 1716277476660}], "start": 1716277476660, "stop": 1716277476726}
+{"uuid": "4309e218-d16d-4522-90d7-7737416e0891", "befores": [{"name": "update_key", "status": "passed", "start": 1716277476660, "stop": 1716277476660}], "start": 1716277476660, "stop": 1716277476726}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/2f128bc8-45c3-48a9-b34d-9a64dda41f29-container.json

+{"uuid": "b02d7b2f-f096-4b7c-9f9e-6e47b6bb1762", "befores": [{"name": "sql_type", "status": "passed", "start": 1716277479627, "stop": 1716277479627}], "start": 1716277479627, "stop": 1716277479689}
+{"uuid": "b02d7b2f-f096-4b7c-9f9e-6e47b6bb1762", "befores": [{"name": "sql_type", "status": "passed", "start": 1716277479627, "stop": 1716277479627}], "start": 1716277479627, "stop": 1716277479689}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/2f397846-69d3-4a33-9d88-72974a777900-container.json

+{"uuid": "860247e5-74d3-4610-a47f-62222c4d0dcf", "befores": [{"name": "mime", "status": "passed", "start": 1716277479830, "stop": 1716277479830}], "start": 1716277479830, "stop": 1716277479904}
+{"uuid": "860247e5-74d3-4610-a47f-62222c4d0dcf", "befores": [{"name": "mime", "status": "passed", "start": 1716277479830, "stop": 1716277479830}], "start": 1716277479830, "stop": 1716277479904}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/30eab59c-9cfa-4324-abc5-602b4ab3f17f-container.json

+{"uuid": "1825498b-eb31-4340-8bb2-5bf9bc1ae405", "befores": [{"name": "mime", "status": "passed", "start": 1716277479311, "stop": 1716277479311}], "start": 1716277479311, "stop": 1716277479586}
+{"uuid": "1825498b-eb31-4340-8bb2-5bf9bc1ae405", "befores": [{"name": "mime", "status": "passed", "start": 1716277479311, "stop": 1716277479311}], "start": 1716277479311, "stop": 1716277479586}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/312733c5-404d-4976-af80-d123e95db3be-attachment.txt

+断言
+断言

InterfaceAutoTest/report/json/BPM接口测试.json/3141c2be-2a20-44d5-b533-c6393ca596ca-container.json

+{"uuid": "5ea05146-f159-42aa-baf3-3f13a397c3c9", "befores": [{"name": "case_data", "status": "passed", "start": 1716277479627, "stop": 1716277479627}], "start": 1716277479627, "stop": 1716277479695}
+{"uuid": "5ea05146-f159-42aa-baf3-3f13a397c3c9", "befores": [{"name": "case_data", "status": "passed", "start": 1716277479627, "stop": 1716277479627}], "start": 1716277479627, "stop": 1716277479695}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/3311acd0-24f6-4dc5-a224-0f6ba4bc3e2c-container.json

+{"uuid": "5478d949-d78d-4b6e-97dd-bcd337673336", "befores": [{"name": "expect_data", "status": "passed", "start": 1716277476775, "stop": 1716277476775}], "start": 1716277476775, "stop": 1716277476916}
+{"uuid": "5478d949-d78d-4b6e-97dd-bcd337673336", "befores": [{"name": "expect_data", "status": "passed", "start": 1716277476775, "stop": 1716277476775}], "start": 1716277476775, "stop": 1716277476916}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/34429e96-891c-4d64-8806-b1c40a067a14-container.json

+{"uuid": "998f1508-95bc-468a-a769-aac0890c1f51", "befores": [{"name": "module_name", "status": "passed", "start": 1716277476773, "stop": 1716277476773}], "start": 1716277476773, "stop": 1716277477018}
+{"uuid": "998f1508-95bc-468a-a769-aac0890c1f51", "befores": [{"name": "module_name", "status": "passed", "start": 1716277476773, "stop": 1716277476773}], "start": 1716277476773, "stop": 1716277477018}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/3602191e-d197-43b9-ba70-e8f77811c56e-container.json

+{"uuid": "e8f055c4-eb53-4feb-8f26-9a28beeaca87", "befores": [{"name": "expect_data", "status": "passed", "start": 1716277479121, "stop": 1716277479121}], "start": 1716277479121, "stop": 1716277479278}
+{"uuid": "e8f055c4-eb53-4feb-8f26-9a28beeaca87", "befores": [{"name": "expect_data", "status": "passed", "start": 1716277479121, "stop": 1716277479121}], "start": 1716277479121, "stop": 1716277479278}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/371322cc-90c4-4d0d-8993-ba5998794b14-container.json

+{"uuid": "08d797b3-b6f2-46f8-8572-abfb896a3753", "befores": [{"name": "sql_type", "status": "passed", "start": 1716277476013, "stop": 1716277476013}], "start": 1716277476013, "stop": 1716277476152}
+{"uuid": "08d797b3-b6f2-46f8-8572-abfb896a3753", "befores": [{"name": "sql_type", "status": "passed", "start": 1716277476013, "stop": 1716277476013}], "start": 1716277476013, "stop": 1716277476152}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/380ad60d-bfe5-4345-99a0-85cc447dc474-container.json

+{"uuid": "814a1be2-18af-42b1-bfcd-3df9af7fd28b", "befores": [{"name": "sql_data", "status": "passed", "start": 1716277474545, "stop": 1716277474545}], "start": 1716277474545, "stop": 1716277474648}
+{"uuid": "814a1be2-18af-42b1-bfcd-3df9af7fd28b", "befores": [{"name": "sql_data", "status": "passed", "start": 1716277474545, "stop": 1716277474545}], "start": 1716277474545, "stop": 1716277474648}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/3817c041-9cd4-4078-a193-d8189ceda793-container.json

+{"uuid": "402234f4-8780-414d-83a5-a6e1babe776b", "befores": [{"name": "case_level", "status": "passed", "start": 1716277475559, "stop": 1716277475559}], "start": 1716277475559, "stop": 1716277475999}
+{"uuid": "402234f4-8780-414d-83a5-a6e1babe776b", "befores": [{"name": "case_level", "status": "passed", "start": 1716277475559, "stop": 1716277475559}], "start": 1716277475559, "stop": 1716277475999}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/3886f37d-14d6-42f4-85ba-7500f2e03fbc-container.json

+{"uuid": "980181f9-ba5c-4449-b4e7-870599e6c1dc", "befores": [{"name": "update_key", "status": "passed", "start": 1716277474445, "stop": 1716277474445}], "start": 1716277474445, "stop": 1716277474501}
+{"uuid": "980181f9-ba5c-4449-b4e7-870599e6c1dc", "befores": [{"name": "update_key", "status": "passed", "start": 1716277474445, "stop": 1716277474445}], "start": 1716277474445, "stop": 1716277474501}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/38d9043a-4810-4cc8-93b6-fd6673c2b436-container.json

+{"uuid": "a0f2b610-133a-4f4a-b0dc-0386c970e76a", "befores": [{"name": "module_name", "status": "passed", "start": 1716277479829, "stop": 1716277479829}], "start": 1716277479829, "stop": 1716277479912}
+{"uuid": "a0f2b610-133a-4f4a-b0dc-0386c970e76a", "befores": [{"name": "module_name", "status": "passed", "start": 1716277479829, "stop": 1716277479829}], "start": 1716277479829, "stop": 1716277479912}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/3b237184-47f8-43df-9633-89dce22801c1-container.json

+{"uuid": "d990cd2b-1379-4047-840a-043ef2c3ed46", "befores": [{"name": "expect_data", "status": "passed", "start": 1716277479714, "stop": 1716277479714}], "start": 1716277479714, "stop": 1716277479794}
+{"uuid": "d990cd2b-1379-4047-840a-043ef2c3ed46", "befores": [{"name": "expect_data", "status": "passed", "start": 1716277479714, "stop": 1716277479714}], "start": 1716277479714, "stop": 1716277479794}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/3be3f922-75bc-4216-a2a8-915ac5099bd9-container.json

+{"uuid": "99c1b165-05f5-4861-9b21-7e72fee9b6b5", "befores": [{"name": "mime", "status": "passed", "start": 1716277476562, "stop": 1716277476562}], "start": 1716277476562, "stop": 1716277476642}
+{"uuid": "99c1b165-05f5-4861-9b21-7e72fee9b6b5", "befores": [{"name": "mime", "status": "passed", "start": 1716277476562, "stop": 1716277476562}], "start": 1716277476562, "stop": 1716277476642}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/3c72d599-fcdf-4dd0-b1d4-b0f6d7125454-container.json

+{"uuid": "e34fdf50-eaf4-4d1f-9ea1-384bd18f04cd", "befores": [{"name": "mime", "status": "passed", "start": 1716277479627, "stop": 1716277479627}], "start": 1716277479627, "stop": 1716277479697}
+{"uuid": "e34fdf50-eaf4-4d1f-9ea1-384bd18f04cd", "befores": [{"name": "mime", "status": "passed", "start": 1716277479627, "stop": 1716277479627}], "start": 1716277479627, "stop": 1716277479697}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/3db4214b-fc16-4a10-af4e-8823d6a0d5e7-container.json

+{"uuid": "247b033c-7d46-4e2b-a078-1ec4bd60c304", "befores": [{"name": "update_key", "status": "passed", "start": 1716277475050, "stop": 1716277475050}], "start": 1716277475050, "stop": 1716277475146}
+{"uuid": "247b033c-7d46-4e2b-a078-1ec4bd60c304", "befores": [{"name": "update_key", "status": "passed", "start": 1716277475050, "stop": 1716277475050}], "start": 1716277475050, "stop": 1716277475146}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/3dfff0ff-5f00-4894-a8fc-2d314b58e256-attachment.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为test_add_org, 期望数据为:{'state': True, 'message': '删除组织成功！', 'value': ''}, 服务器返回的数据为：{"state":true,"message":"删除组织成功！","value":""}
+ERROR    root:test_bpm.py:68 断言成功， 用例数据为test_add_org, 期望数据为:{'state': True, 'message': '删除组织成功！', 'value': ''}, 服务器返回的数据为：{"state":true,"message":"删除组织成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/3e7a5008-84ef-4e0e-a039-a1cd38c1f9f3-container.json

+{"uuid": "f84ed375-94db-4364-8fe5-3ced698bd337", "befores": [{"name": "api_name", "status": "passed", "start": 1716277476659, "stop": 1716277476659}], "start": 1716277476659, "stop": 1716277476763}
+{"uuid": "f84ed375-94db-4364-8fe5-3ced698bd337", "befores": [{"name": "api_name", "status": "passed", "start": 1716277476659, "stop": 1716277476659}], "start": 1716277476659, "stop": 1716277476763}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/3e8d540b-72bb-4b4c-9791-d803f8559b4d-container.json

+{"uuid": "f6c55004-cb24-4dbb-8abf-c0b673307169", "befores": [{"name": "case_title", "status": "passed", "start": 1716277474542, "stop": 1716277474543}], "start": 1716277474542, "stop": 1716277474657}
+{"uuid": "f6c55004-cb24-4dbb-8abf-c0b673307169", "befores": [{"name": "case_title", "status": "passed", "start": 1716277474542, "stop": 1716277474543}], "start": 1716277474542, "stop": 1716277474657}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/400d2727-11d1-414a-ae9c-14de40d52d2c-container.json

+{"uuid": "18f1dda1-3882-47f1-b729-3633b8fe03cf", "befores": [{"name": "module_name", "status": "passed", "start": 1716277475049, "stop": 1716277475049}], "start": 1716277475049, "stop": 1716277475169}
+{"uuid": "18f1dda1-3882-47f1-b729-3633b8fe03cf", "befores": [{"name": "module_name", "status": "passed", "start": 1716277475049, "stop": 1716277475049}], "start": 1716277475049, "stop": 1716277475169}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/408ee43a-ce30-404e-9930-ed54d9b6d31a-container.json

+{"uuid": "230c6a13-0927-44f8-ae95-d0f311e69aa4", "befores": [{"name": "sql_type", "status": "passed", "start": 1716277474338, "stop": 1716277474338}], "start": 1716277474338, "stop": 1716277474401}
+{"uuid": "230c6a13-0927-44f8-ae95-d0f311e69aa4", "befores": [{"name": "sql_type", "status": "passed", "start": 1716277474338, "stop": 1716277474338}], "start": 1716277474338, "stop": 1716277474401}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/4120d75b-ef4a-411b-986d-efa89787b9b9-container.json

+{"uuid": "9c41b828-5e73-47f2-ab59-119513def597", "befores": [{"name": "api_name", "status": "passed", "start": 1716277479713, "stop": 1716277479713}], "start": 1716277479713, "stop": 1716277479813}
+{"uuid": "9c41b828-5e73-47f2-ab59-119513def597", "befores": [{"name": "api_name", "status": "passed", "start": 1716277479713, "stop": 1716277479713}], "start": 1716277479713, "stop": 1716277479813}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/413f7593-c5c5-4b7a-b38b-c4ad83ffdcad-container.json

+{"uuid": "3f3f7970-83ea-4850-985b-a362a6dd4d78", "befores": [{"name": "case_data", "status": "passed", "start": 1716277479714, "stop": 1716277479714}], "start": 1716277479714, "stop": 1716277479798}
+{"uuid": "3f3f7970-83ea-4850-985b-a362a6dd4d78", "befores": [{"name": "case_data", "status": "passed", "start": 1716277479714, "stop": 1716277479714}], "start": 1716277479714, "stop": 1716277479798}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/41e2efc1-8b6b-47f3-b96f-9cf4cfa449e2-container.json

+{"uuid": "8c818746-7dcd-49b0-b56f-e4e695a5e7ca", "befores": [{"name": "update_key", "status": "passed", "start": 1716277476775, "stop": 1716277476775}], "start": 1716277476775, "stop": 1716277476912}
+{"uuid": "8c818746-7dcd-49b0-b56f-e4e695a5e7ca", "befores": [{"name": "update_key", "status": "passed", "start": 1716277476775, "stop": 1716277476775}], "start": 1716277476775, "stop": 1716277476912}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/421da371-eff1-440c-9f12-119b54251f48-container.json

+{"uuid": "bf146ee5-b3d8-4f49-b425-25d92eb826ae", "befores": [{"name": "sql_data", "status": "passed", "start": 1716277474669, "stop": 1716277474669}], "start": 1716277474669, "stop": 1716277474774}
+{"uuid": "bf146ee5-b3d8-4f49-b425-25d92eb826ae", "befores": [{"name": "sql_data", "status": "passed", "start": 1716277474669, "stop": 1716277474669}], "start": 1716277474669, "stop": 1716277474774}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/4280ccce-3ee9-452d-8e18-8a990a6cf2bc-container.json

+{"uuid": "97a01a44-e1dd-46d5-a171-08317b4f6cc3", "befores": [{"name": "mime", "status": "passed", "start": 1716277475559, "stop": 1716277475559}], "start": 1716277475559, "stop": 1716277475994}
+{"uuid": "97a01a44-e1dd-46d5-a171-08317b4f6cc3", "befores": [{"name": "mime", "status": "passed", "start": 1716277475559, "stop": 1716277475559}], "start": 1716277475559, "stop": 1716277475994}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/4398cb73-f513-432a-a392-607660a42bd5-result.json

+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  - 添加组织成功！\n  ?       -\n  + 添加组织成功", "trace": "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000027C560AC5F0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000027C54E3DBE0>, db_fix = <InterfaceAutoTest.common.db.DB object at 0x0000027C5635E750>\nmodule_name = '组织管理', api_name = '添加组织', case_title = '正向用例', case_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792823799155015680', 'exceedLimitNum': 0, 'grade': '', ...}, expect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000027C560AC5F0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000027C54E3DBE0>, db_fix = <InterfaceAutoTest.common.db.DB object at 0x0000027C5635E750>\nmodule_name = '组织管理', api_name = '添加组织', case_title = '正向用例', case_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792823799155015680', 'exceedLimitNum': 0, 'grade': '', ...}, expect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "ae48e463-0f41-40df-8235-516d3c40a775-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'组织管理'"}, {"name": "api_name", "value": "'添加组织'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'高'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/org/v1/org/addOrg'"}, {"name": "mime", "value": "'json'"}, {"name": "case_data", "value": "{'code': 'test_add_org', 'demId': '需要更新', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}"}, {"name": "expect_data", "value": "{'message': '添加组织成功'}"}, {"name": "sql_data", "value": "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}"}, {"name": "sql_type", "value": "'select|delete'"}, {"name": "update_key", "value": "'demId'"}], "start": 1716277476194, "stop": 1716277476377, "uuid": "f5d5dd7c-e705-4c33-845d-257bbe3d1108", "historyId": "2fb04367925e75e547e58cf5a63794dc", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "组织管理"}, {"name": "story", "value": "添加组织"}, {"name": "severity", "value": "高"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "DESKTOP-4FFIKGU"}, {"name": "thread", "value": "4400-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
+{"name": "正向用例", "status": "failed", "statusDetails": {"message": "AssertionError: assert '添加组织成功' == '添加组织成功！'\n  - 添加组织成功！\n  ?       -\n  + 添加组织成功", "trace": "self = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000027C560AC5F0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000027C54E3DBE0>, db_fix = <InterfaceAutoTest.common.db.DB object at 0x0000027C5635E750>\nmodule_name = '组织管理', api_name = '添加组织', case_title = '正向用例', case_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792823799155015680', 'exceedLimitNum': 0, 'grade': '', ...}, expect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n                assert expect_data[key] == res.json().get(key)\n        except AssertionError as e:\n            logging.error(f\"断言失败， 用例数据为{case_data}, 期望数据为:{expect_data}, 服务器返回的数据为：{res.text}\")\n>           raise e\n\ntest_case\\test_demo\\test_bpm.py:66: \n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n\nself = <InterfaceAutoTest.test_case.test_demo.test_bpm.TestBPM object at 0x0000027C560AC5F0>\nreq_fix = <InterfaceAutoTest.requests_method.requsts_method.RequestsMethod object at 0x0000027C54E3DBE0>, db_fix = <InterfaceAutoTest.common.db.DB object at 0x0000027C5635E750>\nmodule_name = '组织管理', api_name = '添加组织', case_title = '正向用例', case_level = '高', method = 'POST', url = 'http://120.46.172.186:8080/api/org/v1/org/addOrg', mime = 'json'\ncase_data = {'code': 'test_add_org', 'demId': '1792823799155015680', 'exceedLimitNum': 0, 'grade': '', ...}, expect_data = {'message': '添加组织成功'}\nsql_data = {'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";', 'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";'}\nsql_type = 'select|delete', update_key = 'demId'\n\n    @allure.epic(\"BPM系统-demo\")  # 测试系统的名称\n    # @allure.feature(\"模块名称\")  # 模块名称\n    # @allure.story(\"接口名称\")    # 接口\n    # @allure.title(\"标题名称\")    # 用例标题\n    # @allure.severity(\"用例的等级\")   # 用例等级\n    @pytest.mark.parametrize(\"module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key\", excel.get_data())\n    def test_bpm(self, req_fix, db_fix, module_name, api_name, case_title, case_level, method, url, mime, case_data, expect_data, sql_data, sql_type, update_key):\n        # 给allure输出的报告添加内容\n        allure.dynamic.feature(module_name)\n        allure.dynamic.story(api_name)\n        allure.dynamic.title(case_title)\n        allure.dynamic.severity(case_level)\n    \n        # 判断sql语句类型是否为select\n        if sql_type == \"select\":\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data)\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 判断sql语句的类型是否为delete\n        elif sql_type == \"delete\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data)\n            # 将数据库中的数据删除完之后，再发送请求\n    \n        # 判断sql语句类型是否为select|delete或者为delete|select\n        elif sql_type == \"select|delete\" or sql_type == \"delete|select\":\n            # 使用DB类对象调用delete_func方法执行删除的sql语句\n            db_fix.delete_func(sql_data[\"delete\"])\n            # 使用DB类对象调用select_func方法执行查询的sql语句，并接收查询结果\n            select_result = db_fix.select_func(sql_data[\"select\"])\n            # 将查询结果更新到用例数据中\n            case_data[update_key] = select_result\n            # 将更新之后的用例数据发送给服务器。\n    \n        # 使用RequestsMethod对象发送请求\n        res = req_fix.request_all(req_method=method, req_url=url, req_mime=mime, case_data=case_data)\n        # 断言\n        try:\n            for key in expect_data:\n>               assert expect_data[key] == res.json().get(key)\nE               AssertionError: assert '添加组织成功' == '添加组织成功！'\nE                 - 添加组织成功！\nE                 ?       -\nE                 + 添加组织成功\n\ntest_case\\test_demo\\test_bpm.py:63: AssertionError"}, "attachments": [{"name": "log", "source": "ae48e463-0f41-40df-8235-516d3c40a775-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'组织管理'"}, {"name": "api_name", "value": "'添加组织'"}, {"name": "case_title", "value": "'正向用例'"}, {"name": "case_level", "value": "'高'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/api/org/v1/org/addOrg'"}, {"name": "mime", "value": "'json'"}, {"name": "case_data", "value": "{'code': 'test_add_org', 'demId': '需要更新', 'exceedLimitNum': 0, 'grade': '', 'limitNum': 0, 'name': '测试添加的组织', 'nowNum': 0, 'orderNo': 0, 'parentId': '0'}"}, {"name": "expect_data", "value": "{'message': '添加组织成功'}"}, {"name": "sql_data", "value": "{'select': 'select ID_ FROM uc_demension WHERE `CODE_`=\"api_auto_test_add_dem\";', 'delete': 'DELETE FROM uc_org WHERE `CODE_`=\"test_add_org\";'}"}, {"name": "sql_type", "value": "'select|delete'"}, {"name": "update_key", "value": "'demId'"}], "start": 1716277476194, "stop": 1716277476377, "uuid": "f5d5dd7c-e705-4c33-845d-257bbe3d1108", "historyId": "2fb04367925e75e547e58cf5a63794dc", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "组织管理"}, {"name": "story", "value": "添加组织"}, {"name": "severity", "value": "高"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "DESKTOP-4FFIKGU"}, {"name": "thread", "value": "4400-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/44b757c2-5762-421c-bea8-8ad3d674ddba-container.json

+{"uuid": "e167309c-4e83-44d9-a872-992086f6c3af", "befores": [{"name": "update_key", "status": "passed", "start": 1716277475296, "stop": 1716277475296}], "start": 1716277475296, "stop": 1716277475389}
+{"uuid": "e167309c-4e83-44d9-a872-992086f6c3af", "befores": [{"name": "update_key", "status": "passed", "start": 1716277475296, "stop": 1716277475296}], "start": 1716277475296, "stop": 1716277475389}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/45f10579-a685-4df8-9c4e-d7d521f47f63-container.json

+{"uuid": "4bffedb0-1dd7-4055-bc98-44c16ad1b197", "befores": [{"name": "url", "status": "passed", "start": 1716277475049, "stop": 1716277475049}], "start": 1716277475049, "stop": 1716277475158}
+{"uuid": "4bffedb0-1dd7-4055-bc98-44c16ad1b197", "befores": [{"name": "url", "status": "passed", "start": 1716277475049, "stop": 1716277475049}], "start": 1716277475049, "stop": 1716277475158}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/45f68f64-abde-457b-a6b2-7e63ae703ce9-container.json

+{"uuid": "c494b57f-3738-45b9-be26-7adbeef420a1", "befores": [{"name": "module_name", "status": "passed", "start": 1716277475557, "stop": 1716277475557}], "start": 1716277475557, "stop": 1716277476004}
+{"uuid": "c494b57f-3738-45b9-be26-7adbeef420a1", "befores": [{"name": "module_name", "status": "passed", "start": 1716277475557, "stop": 1716277475557}], "start": 1716277475557, "stop": 1716277476004}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/4621bd49-44aa-4c7b-b75f-d557c34a4ff5-result.json

+{"name": "反向用例-用户名正确,密码为空", "status": "passed", "attachments": [{"name": "log", "source": "4c7e80ad-0106-4ab1-ba03-ac6a6d4094e5-attachment.txt", "type": "text/plain"}, {"name": "stdout", "source": "0b006032-0b43-48db-a776-2d915e640262-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'认证接口'"}, {"name": "api_name", "value": "'登录系统'"}, {"name": "case_title", "value": "'反向用例-用户名正确,密码为空'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/auth'"}, {"name": "mime", "value": "'application/json'"}, {"name": "case_data", "value": "{'username': 'admin', 'password': ''}"}, {"name": "expect_data", "value": "{'message': '账号或密码错误'}"}, {"name": "sql_data", "value": "None"}, {"name": "sql_type", "value": "None"}, {"name": "update_key", "value": "None"}], "start": 1716277474445, "stop": 1716277474500, "uuid": "e338371a-e3b3-417b-bb2a-3b20b2ac8a92", "historyId": "4164dfc118ea6cc8eeb9ce3984609436", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "认证接口"}, {"name": "story", "value": "登录系统"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "DESKTOP-4FFIKGU"}, {"name": "thread", "value": "4400-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
+{"name": "反向用例-用户名正确,密码为空", "status": "passed", "attachments": [{"name": "log", "source": "4c7e80ad-0106-4ab1-ba03-ac6a6d4094e5-attachment.txt", "type": "text/plain"}, {"name": "stdout", "source": "0b006032-0b43-48db-a776-2d915e640262-attachment.txt", "type": "text/plain"}], "parameters": [{"name": "module_name", "value": "'认证接口'"}, {"name": "api_name", "value": "'登录系统'"}, {"name": "case_title", "value": "'反向用例-用户名正确,密码为空'"}, {"name": "case_level", "value": "'中'"}, {"name": "method", "value": "'POST'"}, {"name": "url", "value": "'http://120.46.172.186:8080/auth'"}, {"name": "mime", "value": "'application/json'"}, {"name": "case_data", "value": "{'username': 'admin', 'password': ''}"}, {"name": "expect_data", "value": "{'message': '账号或密码错误'}"}, {"name": "sql_data", "value": "None"}, {"name": "sql_type", "value": "None"}, {"name": "update_key", "value": "None"}], "start": 1716277474445, "stop": 1716277474500, "uuid": "e338371a-e3b3-417b-bb2a-3b20b2ac8a92", "historyId": "4164dfc118ea6cc8eeb9ce3984609436", "testCaseId": "2de48645219de93dc51c83a53a42f952", "fullName": "test_case.test_demo.test_bpm.TestBPM#test_bpm", "labels": [{"name": "feature", "value": "认证接口"}, {"name": "story", "value": "登录系统"}, {"name": "severity", "value": "中"}, {"name": "epic", "value": "BPM系统-demo"}, {"name": "parentSuite", "value": "test_case.test_demo"}, {"name": "suite", "value": "test_bpm"}, {"name": "subSuite", "value": "TestBPM"}, {"name": "host", "value": "DESKTOP-4FFIKGU"}, {"name": "thread", "value": "4400-MainThread"}, {"name": "framework", "value": "pytest"}, {"name": "language", "value": "cpython3"}, {"name": "package", "value": "test_case.test_demo.test_bpm"}]}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/4910437a-dbf0-45c6-9d4e-92a238ba9a37-container.json

+{"uuid": "4766792b-0603-4dde-9ddd-ef216192463a", "befores": [{"name": "mime", "status": "passed", "start": 1716277479120, "stop": 1716277479121}], "start": 1716277479120, "stop": 1716277479283}
+{"uuid": "4766792b-0603-4dde-9ddd-ef216192463a", "befores": [{"name": "mime", "status": "passed", "start": 1716277479120, "stop": 1716277479121}], "start": 1716277479120, "stop": 1716277479283}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/498f92e5-5971-4d3c-abb3-2e11c549bee5-attachment.txt

+断言
+断言

InterfaceAutoTest/report/json/BPM接口测试.json/49a1fdff-d6f2-4dbd-82f5-00c5dc961838-container.json

+{"uuid": "2078115f-4b6f-4e7d-9fb9-8adb97106cab", "befores": [{"name": "sql_data", "status": "passed", "start": 1716277479121, "stop": 1716277479121}], "start": 1716277479121, "stop": 1716277479275}
+{"uuid": "2078115f-4b6f-4e7d-9fb9-8adb97106cab", "befores": [{"name": "sql_data", "status": "passed", "start": 1716277479121, "stop": 1716277479121}], "start": 1716277479121, "stop": 1716277479275}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/49b16b0e-c769-4e1f-8b08-cec9aab8ed2e-container.json

+{"uuid": "4d341ce6-d9d6-497c-a02c-d111b15e6df0", "befores": [{"name": "module_name", "status": "passed", "start": 1716277476011, "stop": 1716277476011}], "start": 1716277476011, "stop": 1716277476169}
+{"uuid": "4d341ce6-d9d6-497c-a02c-d111b15e6df0", "befores": [{"name": "module_name", "status": "passed", "start": 1716277476011, "stop": 1716277476011}], "start": 1716277476011, "stop": 1716277476169}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/49f3a617-e278-44ec-a93e-b1d204276da7-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNjM4NzYsImlhdCI6MTcxNjI3NzQ3Nn0.WTFiUOZntBNoVfkmCU4jT6zMqchCdTEstehtZL0LdarZ_QMh5BJf-NCCNqpPHeUeR4C1P_bggSmA7_ONzLhBpg","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为None, 期望数据为:{'message': '刷新token成功'}, 服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE3MTYzNjM4NzYsImlhdCI6MTcxNjI3NzQ3Nn0.WTFiUOZntBNoVfkmCU4jT6zMqchCdTEstehtZL0LdarZ_QMh5BJf-NCCNqpPHeUeR4C1P_bggSmA7_ONzLhBpg","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/4a565766-55d6-453e-9b7d-10c52e1bea28-container.json

+{"uuid": "a289ad54-179a-4cf5-8363-3960d7039379", "befores": [{"name": "mime", "status": "passed", "start": 1716277474796, "stop": 1716277474796}], "start": 1716277474796, "stop": 1716277474903}
+{"uuid": "a289ad54-179a-4cf5-8363-3960d7039379", "befores": [{"name": "mime", "status": "passed", "start": 1716277474796, "stop": 1716277474796}], "start": 1716277474796, "stop": 1716277474903}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/4ab171c9-dd2b-47d9-b328-c30d1c7b2e4d-attachment.txt

+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792823799155015680'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""}
+ERROR    root:test_bpm.py:65 断言失败， 用例数据为{'ids': '1792823799155015680'}, 期望数据为:{'message': '删除维度成功'}, 服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/4ac02a7c-9ed4-4eb7-8412-1a65c999e562-container.json

+{"uuid": "276d2ca5-b0dd-4c15-9f6d-2863c1114799", "befores": [{"name": "url", "status": "passed", "start": 1716277476011, "stop": 1716277476011}], "start": 1716277476011, "stop": 1716277476160}
+{"uuid": "276d2ca5-b0dd-4c15-9f6d-2863c1114799", "befores": [{"name": "url", "status": "passed", "start": 1716277476011, "stop": 1716277476011}], "start": 1716277476011, "stop": 1716277476160}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/4b33ed5c-06e7-4d04-9fb4-4f57f5e5a8d0-container.json

+{"uuid": "2eacf12c-013c-4bc0-b694-85bc307c5329", "befores": [{"name": "case_data", "status": "passed", "start": 1716277475050, "stop": 1716277475050}], "start": 1716277475050, "stop": 1716277475151}
+{"uuid": "2eacf12c-013c-4bc0-b694-85bc307c5329", "befores": [{"name": "case_data", "status": "passed", "start": 1716277475050, "stop": 1716277475050}], "start": 1716277475050, "stop": 1716277475151}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/4b3c80e0-4229-4e8f-bbbe-d7d65be74a6c-container.json

+{"uuid": "573073ce-92b8-43c9-b217-41c78382d9b3", "befores": [{"name": "case_title", "status": "passed", "start": 1716277475295, "stop": 1716277475295}], "start": 1716277475295, "stop": 1716277475421}
+{"uuid": "573073ce-92b8-43c9-b217-41c78382d9b3", "befores": [{"name": "case_title", "status": "passed", "start": 1716277475295, "stop": 1716277475295}], "start": 1716277475295, "stop": 1716277475421}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/4b7229c2-b506-4cbc-a4db-96b28c56643c-container.json

+{"uuid": "994673fe-9b01-408f-b429-8613adce90e1", "befores": [{"name": "case_data", "status": "passed", "start": 1716277474925, "stop": 1716277474925}], "start": 1716277474925, "stop": 1716277475029}
+{"uuid": "994673fe-9b01-408f-b429-8613adce90e1", "befores": [{"name": "case_data", "status": "passed", "start": 1716277474925, "stop": 1716277474925}], "start": 1716277474925, "stop": 1716277475029}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/4c7e80ad-0106-4ab1-ba03-ac6a6d4094e5-attachment.txt

+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'username': 'admin', 'password': ''}, 期望数据为:{'message': '账号或密码错误'}, 服务器返回的数据为：{"state":false,"message":"账号或密码错误","logId":"1792823792255385600"}
+ERROR    root:test_bpm.py:68 断言成功， 用例数据为{'username': 'admin', 'password': ''}, 期望数据为:{'message': '账号或密码错误'}, 服务器返回的数据为：{"state":false,"message":"账号或密码错误","logId":"1792823792255385600"}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/4daa729b-84a3-43d5-a9f2-6b3d0e4d1a07-container.json

+{"uuid": "1d3528cc-2b42-40c1-ae2b-d898e9e1c320", "befores": [{"name": "api_name", "status": "passed", "start": 1716277475049, "stop": 1716277475049}], "start": 1716277475049, "stop": 1716277475166}
+{"uuid": "1d3528cc-2b42-40c1-ae2b-d898e9e1c320", "befores": [{"name": "api_name", "status": "passed", "start": 1716277475049, "stop": 1716277475049}], "start": 1716277475049, "stop": 1716277475166}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/4e8e3995-b963-41c3-9488-e9640b0169df-container.json

+{"uuid": "2fc1a82c-ee9b-4f23-b28f-9ece991c075c", "befores": [{"name": "update_key", "status": "passed", "start": 1716277476193, "stop": 1716277476193}], "start": 1716277476193, "stop": 1716277476429}
+{"uuid": "2fc1a82c-ee9b-4f23-b28f-9ece991c075c", "befores": [{"name": "update_key", "status": "passed", "start": 1716277476193, "stop": 1716277476193}], "start": 1716277476193, "stop": 1716277476429}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/4ef915ec-917f-4e1b-9413-4c1a657861b2-container.json

+{"uuid": "cfc123ed-f370-44b9-a400-cc842d85af0a", "befores": [{"name": "module_name", "status": "passed", "start": 1716277474443, "stop": 1716277474443}], "start": 1716277474443, "stop": 1716277474528}
+{"uuid": "cfc123ed-f370-44b9-a400-cc842d85af0a", "befores": [{"name": "module_name", "status": "passed", "start": 1716277474443, "stop": 1716277474443}], "start": 1716277474443, "stop": 1716277474528}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/4f727ee8-d527-476c-9fa5-2580f77e14ba-container.json

+{"uuid": "495c2abe-d331-4aca-bfe9-f3a7e7d0ffd1", "befores": [{"name": "url", "status": "passed", "start": 1716277476472, "stop": 1716277476472}], "start": 1716277476472, "stop": 1716277476545}
+{"uuid": "495c2abe-d331-4aca-bfe9-f3a7e7d0ffd1", "befores": [{"name": "url", "status": "passed", "start": 1716277476472, "stop": 1716277476472}], "start": 1716277476472, "stop": 1716277476545}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/4f860934-9966-491c-aa1f-460f4ff0976f-container.json

+{"uuid": "27f14624-8023-4fb1-ae54-44afc95fbec5", "befores": [{"name": "case_title", "status": "passed", "start": 1716277475049, "stop": 1716277475049}], "start": 1716277475049, "stop": 1716277475165}
+{"uuid": "27f14624-8023-4fb1-ae54-44afc95fbec5", "befores": [{"name": "case_title", "status": "passed", "start": 1716277475049, "stop": 1716277475049}], "start": 1716277475049, "stop": 1716277475165}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/514b587b-1b7a-405a-b9d4-ba5aa14ad8a6-container.json

+{"uuid": "faf9a3cf-f6e0-424d-b178-7a771acce095", "children": ["88ace585-dc6b-4e3a-9708-fcbfe05bdae7", "e338371a-e3b3-417b-bb2a-3b20b2ac8a92", "4072de5e-6227-4644-a2f0-f2eaed9e3ce4", "019dc1e1-87d3-41ce-a11d-c2bde8eb315a", "d3813785-cf39-46ec-8628-8a87da53a6a8", "50301355-695e-4676-99e4-a9d9e75fa3d1", "008b263b-d112-4182-9125-0de067a9d09d", "73e51308-8a66-4afa-ada5-5f74677e21c7", "64f0d0ee-77a7-4c42-9bc3-96e2993eb61d", "25d6e53b-b823-43f0-a916-f8645856c87d", "06e17ded-70be-4adb-a5db-34bd07ebaf38", "6fdd37ef-57fe-4c82-9fc7-4b73cdeddbf5", "f5d5dd7c-e705-4c33-845d-257bbe3d1108", "f62d1e5c-f86d-486a-ae5b-900ce8cf33f6", "1f6537c1-1923-4be6-82f2-da27bee57381", "919beb99-3877-46f2-83fa-ccaed2593128", "e7e80a77-759b-44d8-aa3f-a163356eb619"], "befores": [{"name": "db_fix", "status": "passed", "start": 1716277474130, "stop": 1716277474332}], "afters": [{"name": "db_fix::0", "status": "passed", "start": 1716277480105, "stop": 1716277480105}], "start": 1716277474130, "stop": 1716277480105}
+{"uuid": "faf9a3cf-f6e0-424d-b178-7a771acce095", "children": ["88ace585-dc6b-4e3a-9708-fcbfe05bdae7", "e338371a-e3b3-417b-bb2a-3b20b2ac8a92", "4072de5e-6227-4644-a2f0-f2eaed9e3ce4", "019dc1e1-87d3-41ce-a11d-c2bde8eb315a", "d3813785-cf39-46ec-8628-8a87da53a6a8", "50301355-695e-4676-99e4-a9d9e75fa3d1", "008b263b-d112-4182-9125-0de067a9d09d", "73e51308-8a66-4afa-ada5-5f74677e21c7", "64f0d0ee-77a7-4c42-9bc3-96e2993eb61d", "25d6e53b-b823-43f0-a916-f8645856c87d", "06e17ded-70be-4adb-a5db-34bd07ebaf38", "6fdd37ef-57fe-4c82-9fc7-4b73cdeddbf5", "f5d5dd7c-e705-4c33-845d-257bbe3d1108", "f62d1e5c-f86d-486a-ae5b-900ce8cf33f6", "1f6537c1-1923-4be6-82f2-da27bee57381", "919beb99-3877-46f2-83fa-ccaed2593128", "e7e80a77-759b-44d8-aa3f-a163356eb619"], "befores": [{"name": "db_fix", "status": "passed", "start": 1716277474130, "stop": 1716277474332}], "afters": [{"name": "db_fix::0", "status": "passed", "start": 1716277480105, "stop": 1716277480105}], "start": 1716277474130, "stop": 1716277480105}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/528d3e44-ae57-40a3-a78e-046a79db317c-container.json

+{"uuid": "45f6f39f-6be1-489d-ba5e-ac6a5204093d", "befores": [{"name": "case_level", "status": "passed", "start": 1716277479626, "stop": 1716277479626}], "start": 1716277479626, "stop": 1716277479702}
+{"uuid": "45f6f39f-6be1-489d-ba5e-ac6a5204093d", "befores": [{"name": "case_level", "status": "passed", "start": 1716277479626, "stop": 1716277479626}], "start": 1716277479626, "stop": 1716277479702}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/52954775-ccab-4e6b-bf99-c113f5bcb002-container.json

+{"uuid": "1c7f90c8-e15f-4674-9ed3-962f5a589813", "befores": [{"name": "update_key", "status": "passed", "start": 1716277476473, "stop": 1716277476473}], "start": 1716277476473, "stop": 1716277476533}
+{"uuid": "1c7f90c8-e15f-4674-9ed3-962f5a589813", "befores": [{"name": "update_key", "status": "passed", "start": 1716277476473, "stop": 1716277476473}], "start": 1716277476473, "stop": 1716277476533}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/5376bcee-d901-4d54-acf1-719dc0cf5c0c-container.json

+{"uuid": "5471a819-cdf7-44ed-8cbe-bfb40b3e1459", "befores": [{"name": "module_name", "status": "passed", "start": 1716277476561, "stop": 1716277476561}], "start": 1716277476561, "stop": 1716277476651}
+{"uuid": "5471a819-cdf7-44ed-8cbe-bfb40b3e1459", "befores": [{"name": "module_name", "status": "passed", "start": 1716277476561, "stop": 1716277476561}], "start": 1716277476561, "stop": 1716277476651}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/55060d2b-d82f-4a3d-9171-05616bd5ba9e-container.json

+{"uuid": "9b97b4e1-e194-4cc1-a7de-d81834b42d77", "befores": [{"name": "expect_data", "status": "passed", "start": 1716277475295, "stop": 1716277475295}], "start": 1716277475295, "stop": 1716277475413}
+{"uuid": "9b97b4e1-e194-4cc1-a7de-d81834b42d77", "befores": [{"name": "expect_data", "status": "passed", "start": 1716277475295, "stop": 1716277475295}], "start": 1716277475295, "stop": 1716277475413}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/58addb32-3da7-49dc-b2c8-ee9b1c5b1398-container.json

+{"uuid": "650d6bca-7ef1-4e7b-8ec2-3aa9f79a912c", "befores": [{"name": "api_name", "status": "passed", "start": 1716277476471, "stop": 1716277476471}], "start": 1716277476471, "stop": 1716277476551}
+{"uuid": "650d6bca-7ef1-4e7b-8ec2-3aa9f79a912c", "befores": [{"name": "api_name", "status": "passed", "start": 1716277476471, "stop": 1716277476471}], "start": 1716277476471, "stop": 1716277476551}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/596c0ecc-08c4-4c21-a879-c165bc894f44-container.json

+{"uuid": "bf049094-1ccc-4642-82b8-4b91e8e4bee9", "befores": [{"name": "method", "status": "passed", "start": 1716277474543, "stop": 1716277474544}], "start": 1716277474543, "stop": 1716277474654}
+{"uuid": "bf049094-1ccc-4642-82b8-4b91e8e4bee9", "befores": [{"name": "method", "status": "passed", "start": 1716277474543, "stop": 1716277474544}], "start": 1716277474543, "stop": 1716277474654}
\ No newline at end of file

InterfaceAutoTest/report/json/BPM接口测试.json/598cd417-2d03-43c6-8a86-5bd46cd128a9-attachment.txt

+断言成功
+断言成功

InterfaceAutoTest/report/json/BPM接口测试.json/59c132ce-0693-479e-898f-dfa0b610715c-container.json

+{"uuid": "ff24b016-1ad6-4c8d-8997-fa9d2092ef0f", "befores": [{"name": "mime", "status": "passed", "start": 1716277474544, "stop": 1716277474544}], "start": 1716277474544, "stop": 1716277474651}
+{"uuid": "ff24b016-1ad6-4c8d-8997-fa9d2092ef0f", "befores": [{"name": "mime", "status": "passed", "start": 1716277474544, "stop": 1716277474544}], "start": 1716277474544, "stop": 1716277474651}
\ No newline at end of file