上传login.py

1/1.txt

+测试

login/APIAutoTest_v2/common/__init__.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_57
+# FileName:      __init__.py
+# Author:       xxxxxxx
+# Datetime:     2023/11/2 14:49
+# Description:
+# 
+# ---------------------------------------------------------------------------
+from login.APIAutoTest_v2.common.log import write_log
+
+
+# 在使用包的时候，提前加载，只加载一次
+log = write_log()
\ No newline at end of file

login/APIAutoTest_v2/common/db.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_57
+# FileName:      db.py
+# Author:       xxxxxxx
+# Datetime:     2023/11/2 14:36
+# Description:
+# 
+# ---------------------------------------------------------------------------
+import pymysql
+from login.APIAutoTest_v2.common import log
+from login.APIAutoTest_v2.common.read_ini import ReadIni
+
+
+class DB:
+    def __init__(self):
+        """获取链接对象，再获取游标对象"""
+        # 创建ReadIni对象
+        read_ini = ReadIni()
+        # 链接数据库，获取链接对象
+        try:
+            self.conn = pymysql.connect(
+                host=read_ini.get_sql_message("host"),
+                port=int(read_ini.get_sql_message("port")),
+                user=read_ini.get_sql_message("user"),
+                password=read_ini.get_sql_message("pwd"),
+                database=read_ini.get_sql_message("database"),
+                charset="utf8"
+            )
+            self.cursor = self.conn.cursor()
+        except:
+            log.error("链接数据库错误")
+            raise pymysql.MySQLError("链接数据库错误")
+
+
+    def close(self):
+        self.cursor.close()
+        self.conn.close()
+
+    def delete(self, sql):
+        """执行删除的sql语句"""
+        try:
+            self.cursor.execute(sql)
+            self.conn.commit()
+        except:
+            log.error("执行删除的sql语句错误，请察看sql语句是否正确")
+            raise ValueError("执行删除的sql语句错误，请察看sql语句是否正确")
+
+    def select(self, sql, number=None):
+        try:
+            self.cursor.execute(sql)
+            select_result = self.cursor.fetchall()
+            # 判断查询的结果是否为空的元组，如果为空的元组返回None，如果不为空的元组，返回查询的第一个结果
+            if select_result:
+                return select_result[0][0]
+        except:
+            log.error("执行查询的sql语句错误，请察看sql语句是否正确")
+            raise ValueError("执行查询的sql语句错误，请察看sql语句是否正确")
+
+
+if __name__ == '__main__':
+    db = DB()
+    # del_sql = """DELETE FROM uc_demension `CODE_`="dem_test57_abc";"""
+    # db.delete(del_sql)
+
+    sel_sql = """SELECT DEM_NAME_ FROM uc_demension LIMIT 1"""
+    print(db.select(sel_sql))
\ No newline at end of file

login/APIAutoTest_v2/common/log.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_57
+# FileName:      log.py
+# Author:       xxxxxxx
+# Datetime:     2023/11/2 14:02
+# Description:
+# 
+# ---------------------------------------------------------------------------
+import logging
+import os
+
+
+def write_log():
+    # 创建logger对象
+    logger = logging.getLogger("老黄")
+    # 动态获取日志文件保存的路径
+    log_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), "report/log/log.log")
+    # 创建handler
+    handler = logging.FileHandler(log_path, mode="a", encoding="utf-8")
+    # 设置日志文件中内容的格式
+    format = logging.Formatter('%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s - %(name)s')
+    # 将日志的格式添加到handler中
+    handler.setFormatter(format)
+    # 将handler添加到logger中
+    logger.addHandler(handler)
+    # 返回logger对象
+    return logger
+
+def write_log1():
+    logger = logging.getLogger("老黄")
+
+    log_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), "report/log/log.log")
+
+    hander = logging.FileHandler(log_path, mode="a", encoding="utf-8")
+
+    format = logging.Formatter('%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s - %(name)s')
+
+    hander.setFormatter(format)
+
+    logger.addHandler(hander)
+
+    return logger
\ No newline at end of file

login/APIAutoTest_v2/common/read_excel.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_57
+# FileName:      read_excel.py
+# Author:       xxxxxxx
+# Datetime:     2023/11/2 15:31
+# Description:
+# 
+# ---------------------------------------------------------------------------
+import openpyxl
+
+from login.APIAutoTest_v2.common import log
+from login.APIAutoTest_v2.common.read_ini import ReadIni
+from login.APIAutoTest_v2.common.read_json import read_json
+
+
+class ReadExcel:
+    def __init__(self):
+        """获取除了ini文件以外所有文件的路径，再获取工作表，读取所有的json文件"""
+        # 创建ReadIni对象
+        self.read_ini = ReadIni()
+        # 获取除了ini文件以外所有文件的路径
+        excel_path = self.read_ini.get_file_path("excel")
+        case_data_path = self.read_ini.get_file_path("case")
+        expect_data_path = self.read_ini.get_file_path("expect")
+        sql_data_path = self.read_ini.get_file_path("sql")
+
+        # 获取工作表的名称
+        table_name = self.read_ini.get_table_name("table_name")
+
+        # 获取工作簿
+        wb = openpyxl.load_workbook(excel_path)
+        try:
+            self.ws = wb[table_name]
+        except:
+
+            log.error("获取excel的工作表出错，请求确认工作表的名称是否正确？？？")
+            raise NameError("获取excel的工作表出错，请求确认工作表的名称是否正确？？？")
+
+        # 调用read_json函数读取所有的json文件
+        self.case_data_dict = read_json(case_data_path)
+        self.expect_data_dict = read_json(expect_data_path)
+        self.sql_data_dict = read_json(sql_data_path)
+
+    def __get_cell_value(self, column: str, row: int) -> str:
+        """根据列号和行号，获取指定单元格数据"""
+        # 使用：工作表["列号行号"].value
+        try:
+            value = self.ws[column + str(row)].value
+        except:
+            log.error("传入的列号或行号有错误,请按照规定传入")
+            raise NameError("传入的列号或行号有错误,请按照规定传入")
+
+        # 判断value是否为None如果为None，返回None
+        if value is None:
+            return None
+        # 判断value去掉前后空格之后是否为空的字符串，如果为空的字符串返回None，如果不是，返回去掉前后空的字符串
+        elif value.strip():
+            return value.strip()
+
+    def module_name(self, row):
+        """根据行号，获取模块名称"""
+        return self.__get_cell_value("B", row)
+
+    def api_name(self, row):
+        """根据行号，获取接口名称"""
+        return self.__get_cell_value("C", row)
+
+    def case_url(self, row):
+        """根据行号，获取请求的url"""
+        # 使用ReadIni对象，调用get_host获取域名
+        return self.read_ini.get_host("host") + self.__get_cell_value("F", row)
+
+    def case_method(self, row):
+        """根据行号，获取请求方法"""
+        return self.__get_cell_value("g", row)
+
+    def case_mime(self, row):
+        """根据行号，获取媒体类型"""
+        # 获取媒体类型的值
+        mime = self.__get_cell_value("H",row)
+        # 判断媒体类型的值是否为None如果为None，返回None，如果不为None,将媒体类型的值，转小写，并返回
+        if mime:
+            return mime.lower()
+
+    def case_data(self, row):
+        """根据行号，获取请求的用例数据"""
+        # 调用私有方法获取用例数据的key
+        case_data_key = self.__get_cell_value("i", row)
+        # 判断用例数据的key是否为None，如果为None，返回None。
+        if case_data_key:
+            # 获取模块名称
+            module_name = self.module_name(row)
+            # 获取接口名称
+            api_name = self.api_name(row)
+            # 提取用例数据，并返回
+            return self.case_data_dict[module_name][api_name][case_data_key]
+
+    def expect_data(self, row):
+        """根据行号，获取期望数据"""
+        # 调用私有方法获取用例数据的key
+        expect_data_key = self.__get_cell_value("j", row)
+        # 获取模块名称
+        module_name = self.module_name(row)
+        # 获取接口名称
+        api_name = self.api_name(row)
+        # 提取期望数据
+        return self.expect_data_dict[module_name][api_name][expect_data_key]
+
+    def sql_type(self, row):
+        """根据行号，获取sql语句的类型"""
+        # 可以根据sql语句的类型，选择DB类中的不同方法执行我们的sql语句。
+        # 调用私有方法获取sql语句类型的只
+        sql_type_value = self.__get_cell_value("k", row)
+        # 判断sql语句类型的值是否为None，如果为None，返回None, 判断sql语句类型的值如果不为None，将sql语句类型的值转小写并返回
+        if sql_type_value:
+            return sql_type_value.lower()
+
+    def sql_data(self, row):
+        """根据行号，获取sql语句"""
+        # 获取sql语句的key
+        sql_data_key = self.__get_cell_value("l", row)
+        # 判断sql语句的key是否为None，如果是，返回None# 判断sql语句的key如果不为None，就提取sql语句
+        if sql_data_key:
+            # 获取模块名称
+            module_name = self.module_name(row)
+            # 获取接口名称
+            api_name = self.api_name(row)
+            # 提取sql语句,并返回
+            return self.sql_data_dict[module_name][api_name][sql_data_key]
+
+    def update_key(self, row):
+        """根据行号，获取用例更新的key"""
+        # 调用私有方法获取更新的key
+        return self.__get_cell_value("m", row)
+
+    def get_data(self):
+        """提取所有的测试数据，存放在一个二维列表中，每行就是一个子列表"""
+        # 创建一个空列表，用于存放所有的数据
+        list_data = []
+        # 循环所有的行，提取测试数据
+        for row in range(2, self.ws.max_row+1):
+            # url
+            case_url = self.case_url(row)
+            # method
+            case_method = self.case_method(row)
+            # mime
+            case_mime = self.case_mime(row)
+            # case_data
+            case_data = self.case_data(row)
+            # expect_data
+            expect_data = self.expect_data(row)
+            # sql_type
+            sql_type = self.sql_type(row)
+            # sql_sentence
+            sql_sentence = self.sql_data(row)
+            # update_key
+            update_key = self.update_key(row)
+            list_data.append([case_url, case_method, case_mime, case_data, expect_data, sql_type, sql_sentence, update_key])
+        else:
+            return list_data
+
+
+if __name__ == '__main__':
+    read_excel = ReadExcel()
+    print(read_excel.get_data())

login/APIAutoTest_v2/common/read_ini.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_57
+# FileName:      read_ini.py
+# Author:       xxxxxxx
+# Datetime:     2023/11/2 14:08
+# Description:
+# 
+# ---------------------------------------------------------------------------
+import configparser
+import os
+from login.APIAutoTest_v2.common import log
+
+
+class ReadIni:
+    def __init__(self):
+        """获取ini文件的路径，再使用Configparser对象的read方法读取ini文件"""
+        # 获取data_config的路径
+        self.data_config = os.path.join(os.path.dirname(os.path.dirname(__file__)), "data_config")
+        # 获取ini文件的路径
+        ini_path = os.path.join(self.data_config, 'config.ini')
+        # 创建Configparser对象
+        self.conf = configparser.ConfigParser()
+        # 使用Configparser对象的read方法读取ini文件
+        self.conf.read(ini_path, encoding="utf-8")
+
+    def get_file_path(self, key):
+        """根据key获取file节点下文件的路径"""
+        # 获取file节点下key对应的文件名称
+        file_name = self.conf.get("file", key)
+        # 拼接文件的路径
+        file_path = os.path.join(self.data_config, file_name)
+        # 判断文件的路径是否合法，如果不合法，抛出错误的同时写入日志
+        if os.path.isfile(file_path):
+            return file_path
+        else:
+            # 不合法写入日志
+            log.error("获取的文件路径不合法")
+            raise FileExistsError("获取的文件路径不合法")
+
+    def get_host(self, key):
+        """根据key，获取被测系统的域名"""
+        return self.conf.get("host", key)
+
+    def get_table_name(self, key):
+        """根据key，获取工作表名称"""
+        return self.conf.get("table", key)
+
+    def get_sql_message(self, key):
+        """根据key，获取数据库的链接信息"""
+        return self.conf.get("sql", key)
+
+
+
+
+if __name__ == '__main__':
+    read_ini = ReadIni()
+    print(read_ini.get_sql_message("host"))
\ No newline at end of file

login/APIAutoTest_v2/common/read_json.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_57
+# FileName:      read_json.py
+# Author:       xxxxxxx
+# Datetime:     2023/11/2 14:26
+# Description:
+# 
+# ---------------------------------------------------------------------------
+import json
+import os
+from login.APIAutoTest_v2.common import log
+
+
+def read_json(filename):
+    """读取json文件，并将json文件内容转成python对象，再返回"""
+    # 判断文件的路径是否合法
+    if os.path.isfile(filename) and filename.endswith(".json"):
+        # 打开文件，并获取文件的内容，再转成python对象，再返回
+        try:
+            with open(filename, mode="r", encoding="utf-8") as f:
+                return json.load(f)
+        except:
+            log.error("读取json文件错误")
+            raise FileExistsError("读取json文件错误")
+    else:
+        log.error("json文件的路径不合法")
+        raise FileNotFoundError("json文件的路径不合法")
+
+
+
+if __name__ == '__main__':
+    print(read_json(r"E:\train_test\7python\笔记\login\APIAutoTest_v2\data_config\case_data.json"))

login/APIAutoTest_v2/data_config/case_data.json

+{
+    "认证接口":{
+        "登录系统":{
+            "LoginSuccess": {"password": "MTIzNDU2","username": "admin"},
+            "LoginErrorUsernameLong":{"password": "MTIzNDU2","username": "adminadminadminadminadminadmin"},
+            "LoginErrorUsernameShort":{"password": "MTIzNDU2","username": "a"},
+            "LoginErrorUsernameNone":{"password": "MTIzNDU2","username": ""},
+            "LoginErrorUsernameSpecial":{"password": "MTIzNDU2","username": "@#!@#!@"},
+            "LoginErrorPwdLong":{"password": "MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2","username": "admin"},
+            "LoginErrorPwdShort":{"password": "m","username": "admin"},
+            "LoginErrorPwdNone":{"password": "","username": "admin"},
+            "LoginErrorPwdSpecial":{"password": "@#!@#!@","username": "admin"},
+            "LoginErrorPwdError":{"password": "MTIzNDU222","username": "admin"}
+        }
+    },
+    "维度管理": {
+        "添加维度": {
+            "AddDemSuccess": {
+                    "code": "lzh",
+                    "description": "艺术就是派大星",
+                    "isDefault": 0,
+                    "name": "艺术就是爆炸"
+                }
+        },
+        "根据维度编码获取维度信息": {
+            "GetDemMessageSuccess": {"code": "lzh"}
+        },
+        "根据维度编码删除维度": {
+            "DeleteDemSuccess": {"ids": "不知道"}
+        }
+    }
+}
+
+

login/APIAutoTest_v2/data_config/config.ini

+[file]
+;case为用例数据文件
+case=case_data.json
+;expect为期望数据文件
+expect=expect_data.json
+;excel为用例管理文件
+excel=APIAutoTest.xlsx
+;sql语句的json文件
+sql=sql.json
+
+[host]
+;host为被测系统的域名
+host=http://120.46.172.186:8080
+
+[table]
+;table_name为excel的工作表名称
+table_name=BPM
+
+[sql]
+;链接数据库的配置
+host=120.46.172.186
+port=3306
+user=root
+pwd=root@2023
+database=eipsaas
\ No newline at end of file

login/APIAutoTest_v2/data_config/expect_data.json

+{
+    "认证接口":{
+        "登录系统":{
+            "LoginSuccess": {"username": "超级管理员","account": "admin", "loginStatus": true},
+            "LoginErrorUsernameLong":{"state": false, "message":"账号或密码错误"},
+            "LoginErrorUsernameShort":{"state": false, "message":"账号或密码错误"},
+            "LoginErrorUsernameNone":{"state": false, "message":"账号或密码错误"},
+            "LoginErrorUsernameSpecial":{"state": false, "message":"账号或密码错误"},
+            "LoginErrorPwdLong":{"state": false, "message":"账号或密码错误"},
+            "LoginErrorPwdShort":{"state": false, "message":"账号或密码错误"},
+            "LoginErrorPwdNone":{"state": false, "message":"账号或密码错误"},
+            "LoginErrorPwdSpecial":{"state": false, "message":"账号或密码错误"},
+            "LoginErrorPwdError":{"state": false, "message":"账号或密码错误"}
+        },
+        "刷新token": {
+            "RefreshSuccess": {"loginStatus": true}
+        }
+    },
+    "维度管理": {
+        "添加维度": {
+            "AddDemSuccess": {"state": true, "message": "添加维度成功！"}
+        },
+        "根据维度编码获取维度信息": {
+            "GetDemMessageSuccess": {"demCode": "lzh", "name": "艺术就是爆炸"}
+        },
+        "根据维度编码删除维度": {
+            "DeleteDemSuccess": {"state": true, "message": "删除维度成功！"}
+        }
+    }
+}
\ No newline at end of file

login/APIAutoTest_v2/data_config/sql.json

+{
+    "维度管理": {
+        "添加维度": {
+            "AddDemSuccess": "DELETE FROM uc_demension WHERE `CODE_`=\"lzh\";"
+        },
+        "根据维度编码删除维度": {
+            "DeleteDemSuccess": "SELECT ID_ from uc_demension WHERE `CODE_`=\"lzh\";"
+        }
+    }
+}
\ No newline at end of file

login/APIAutoTest_v2/report/log/log.log

+2023-11-02 14:53:05,504 - db.py[line:32] - ERROR: 链接数据库错误 - 老黄
+2023-11-02 15:02:06,487 - db.py[line:32] - ERROR: 链接数据库错误 - 老黄
+2023-11-02 15:02:43,794 - db.py[line:45] - ERROR: 执行删除的sql语句错误，请察看sql语句是否正确 - 老黄
+2023-11-02 15:03:19,574 - db.py[line:45] - ERROR: 执行删除的sql语句错误，请察看sql语句是否正确 - 老黄
+2023-11-02 15:34:56,536 - read_ini.py[line:38] - ERROR: 获取的文件路径不合法 - 老黄
+2023-11-02 15:38:45,336 - read_excel.py[line:35] - ERROR: 获取excel的工作表出错，请求确认工作表的名称是否正确？？？ - 老黄
+2023-11-02 15:45:56,761 - read_excel.py[line:50] - ERROR: 传入的列号或行号有错误,请按照规定传入 - 老黄
+2023-11-02 15:46:27,394 - read_excel.py[line:50] - ERROR: 传入的列号或行号有错误,请按照规定传入 - 老黄
+2023-11-02 17:25:04,742 - test_bpm.py[line:53] - ERROR: 断言失败，期望数据为：{'username': '超级管理', 'account': 'admin', 'loginStatus': True}服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE2OTkwMDM1MDUsImlhdCI6MTY5ODkxNzEwNX0.hIb8vYMX8e70FyclmfJ3Fr1bVOlpfJMA3PlFzyRte8EFwRJXzjLNjmVOTHqUxNtyEMnB51722Nm5g6J0VU9UuA","username":"超级管理员","account":"admin","userId":"1","expiration":86400,"loginStatus":true,"userAttrs":{"tenantId":"-1"}} - 老黄
+2023-11-02 17:25:05,839 - test_bpm.py[line:53] - ERROR: 断言失败，期望数据为：{'message': '刷新成功'}服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE2OTkwMDM1MDYsImlhdCI6MTY5ODkxNzEwNn0.ih5-gHXqveyCzxXlvAxohXgnVnK9kiW1EXqUuAsPbiRNjclS6PZ1S3P4BaVmib9JXvz4kCg87n01tH8HHUCo9Q","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}} - 老黄
+2023-11-02 17:25:06,133 - test_bpm.py[line:53] - ERROR: 断言失败，期望数据为：{'state': True, 'message': '删除维度成功'}服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""} - 老黄
+2023-11-02 18:25:00,679 - test_bpm.py[line:53] - ERROR: 断言失败，期望数据为：{'username': '超级管理', 'account': 'admin', 'loginStatus': True}服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE2OTkwMDcxMDAsImlhdCI6MTY5ODkyMDcwMH0.9WM8hVRu0-JiP01KftD0C9UB-W1aGyRpdpRrZV0U0GKznGVNzLODVWAxKyjG31bori507OLYF75G1_Hn4XUdrg","username":"超级管理员","account":"admin","userId":"1","expiration":86400,"loginStatus":true,"userAttrs":{"tenantId":"-1"}} - 老黄
+2023-11-02 18:25:01,699 - test_bpm.py[line:53] - ERROR: 断言失败，期望数据为：{'message': '刷新成功'}服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE2OTkwMDcxMDEsImlhdCI6MTY5ODkyMDcwMX0.kxXAhwig9iFc5SzpzpSi5mq3Pppua1ny6cq_pHH6y_qWJ8MQQuDWUI5vCWjK0GYC9TC1fhLO9Mym3qGxktv6aQ","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}} - 老黄
+2023-11-02 18:25:01,991 - test_bpm.py[line:53] - ERROR: 断言失败，期望数据为：{'state': True, 'message': '删除维度成功'}服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""} - 老黄
+2023-11-02 18:25:42,696 - test_bpm.py[line:53] - ERROR: 断言失败，期望数据为：{'message': '刷新成功'}服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE2OTkwMDcxNDIsImlhdCI6MTY5ODkyMDc0Mn0.7KqyW8YefuQ2AzsanXPRQVoCHEpCExeov-Z6dIXLCuar0XR1JbKDLz4ZBngP6-jgxxu8E3780k0jfJX9GwgsJQ","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}} - 老黄
+2023-11-02 18:25:43,051 - test_bpm.py[line:53] - ERROR: 断言失败，期望数据为：{'state': True, 'message': '删除维度成功'}服务器返回的数据为：{"state":true,"message":"删除维度成功！","value":""} - 老黄
+2023-11-02 18:27:13,679 - test_bpm.py[line:53] - ERROR: 断言失败，期望数据为：{'message': '刷新成功'}服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE2OTkwMDcyMzMsImlhdCI6MTY5ODkyMDgzM30.xueOyYQaufOnmmLAQmrv9XknJ9oHxUtvHSTqurunQIS2CTZTHi_khPuVC5mYxy-wNvZObZU3HXiZdlWmysyK_A","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}} - 老黄
+2023-11-02 19:14:17,851 - read_json.py[line:27] - ERROR: json文件的路径不合法 - 老黄
+2023-11-03 09:20:13,674 - test_bpm.py[line:56] - ERROR: 断言失败，期望数据为：{'message': '刷新成功'}服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE2OTkwNjA4MTMsImlhdCI6MTY5ODk3NDQxM30.4-cgxcLu7cjo6A4BMRjnL3dpKRYJB-FSGeM3Kqjk_jKiK9gbVlfMH2_c2FRJXnIjHwqVLAr2AaB8c6e6k4A1jw","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}} - 老黄
+2023-11-03 09:20:34,236 - test_bpm.py[line:56] - ERROR: 断言失败，期望数据为：{'message': '刷新成功'}服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE2OTkwNjA4MzQsImlhdCI6MTY5ODk3NDQzNH0.JR3LB350yb69BThR2r82gHQtlb3w_dHyiYy-NAWBB1ULr4v__GgbCkxp35phpOW71yA1FuVNWZTbQBxq2_0f-g","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}} - 老黄
+2023-11-03 09:20:59,308 - test_bpm.py[line:56] - ERROR: 断言失败，期望数据为：{'message': '刷新成功'}服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE2OTkwNjA4NTksImlhdCI6MTY5ODk3NDQ1OX0.U_1vck58_hEmOhwR8zPUHNqYZwuwwzgDHkMlb-GAXViVVs-hXHcJj6ddckYN74trAI6B9fb5ZhvH9vto6nGFLg","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}} - 老黄
+2023-11-03 10:30:34,909 - test_bpm.py[line:56] - ERROR: 断言失败，期望数据为：{'message': '刷新成功'}服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE2OTkwNjUwMzQsImlhdCI6MTY5ODk3ODYzNH0.EsxfTXZ4Zpc3CMXDlqsZUTvfJA3R_8DnC_tU3XzRqNk4kqbrT68waRnQuzzN-ekaKRDG6LngHhAa4SIPfmIXEw","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}} - 老黄
+2023-11-08 16:01:46,878 - test_bpm.py[line:56] - ERROR: 断言失败，期望数据为：{'message': '刷新成功'}服务器返回的数据为：{"token":"eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsInRlbmFudElkIjoiLTEiLCJleHAiOjE2OTk1MTY5MDYsImlhdCI6MTY5OTQzMDUwNn0.s_T-cWw3wfXnF5yw_ukgEGVawcUKkxKTuHXgGV4qRqeGKLiAvZsxV3rnffFCtqQiU0X9J0qOEbBAdRh0-Ln-uA","username":"","account":"","userId":"","loginStatus":true,"userAttrs":{}} - 老黄

login/APIAutoTest_v2/requests_method/requests_method.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_57
+# FileName:      requests_method.py
+# Author:       xxxxxxx
+# Datetime:     2023/11/2 16:43
+# Description:
+# 
+# ---------------------------------------------------------------------------
+import base64
+
+import requests
+
+from login.APIAutoTest_v2.common import log
+from login.APIAutoTest_v2.common.read_ini import ReadIni
+
+
+class RequestsMethod:
+    def __init__(self):
+        """管理登录状态"""
+        # 创建ReadIni对象
+        read_ini = ReadIni()
+        # 拼接登录url
+        login_url = read_ini.get_host("host") + "/auth"
+        # 配置登录数据
+        login_data = {"username": "admin", "password": base64.b64encode("123456".encode()).decode()}
+        # 创建Session对象
+        self.bpm_session = requests.sessions.Session()
+        # 发送登录请求
+        try:
+            res = self.bpm_session.request(method="post", url=login_url, json=login_data)
+        except:
+            log.error("请确认域名是否配置正确。。。")
+            raise requests.ConnectionError("请确认域名是否配置正确。。。")
+
+        # 获取服务器返回的token，并更新到Session对象的headers中
+        self.bpm_session.headers["Authorization"] = "Bearer " + res.json().get("token")
+
+    def request_all(self, req_method, req_url, req_mime=None, case_data=None):
+
+        if req_mime == "json" or req_mime == "application/json":
+            return self.bpm_session.request(method=req_method, url=req_url, json=case_data)
+
+        elif req_mime == "x-www-form-urlencoded" or req_mime == "application/x-www-form-urlencoded":
+            return self.bpm_session.request(method=req_method, url=req_url, data=case_data)
+
+        elif req_mime == "form-data" or req_mime == "multipart/form-data":
+            return self.bpm_session.request(method=req_method, url=req_url, files=case_data)
+
+        elif req_mime == "query" or req_mime == "params" or req_mime == "param":
+            return self.bpm_session.request(method=req_method, url=req_url, params=case_data)
+
+        elif req_mime is None:
+            return self.bpm_session.request(method=req_method, url=req_url)
+
+        else:
+            log.error("传入的媒体类型错误，请求自行封装")
+            raise NameError("传入的媒体类型错误，请求自行封装")
\ No newline at end of file

login/APIAutoTest_v2/test_case/conftest.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_57
+# FileName:      conftest.py
+# Author:       xxxxxxx
+# Datetime:     2023/11/2 16:55
+# Description:
+# 
+# ---------------------------------------------------------------------------
+import pytest
+
+from login.APIAutoTest_v2.common.db import DB
+from login.APIAutoTest_v2.requests_method.requests_method import RequestsMethod
+
+
+@pytest.fixture(scope="session")
+def req_fix():
+    # 创建RequestsMethod类对象，并返回
+    req = RequestsMethod()
+    return req
+
+
+@pytest.fixture(scope="session")
+def db_fix():
+    # 创建DB类对象
+    db = DB()
+    yield db
+    db.close()
\ No newline at end of file

login/APIAutoTest_v2/test_case/test_bpm.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_57
+# FileName:      test_bpm.py
+# Author:       xxxxxxx
+# Datetime:     2023/11/2 16:52
+# Description:
+# 
+# ---------------------------------------------------------------------------
+import pytest
+
+from login.APIAutoTest_v2.common import log
+from login.APIAutoTest_v2.common.read_excel import ReadExcel
+
+
+class TestBPM:
+
+    @pytest.mark.parametrize("case_url, case_method, case_mime, case_data, expect_data, sql_type, sql_sentence, update_key", ReadExcel().get_data())
+    def test_bpm(self, req_fix, db_fix, case_url, case_method, case_mime, case_data, expect_data, sql_type, sql_sentence, update_key):
+        print(case_url, case_method, case_mime, case_data, expect_data, sql_type, sql_sentence, update_key)
+
+        # 判断sql语句的类型是否为delete并且sql语句不为None，如果条件满足就调用DB类中delete方法执行删除sql语句
+        if sql_type == "delete" and sql_sentence is not None:
+            # DB类对象为自定固件db_fix
+            db_fix.delete(sql_sentence)
+            # 使用RequestsMethod类对象调用request_all方法发送请求，自定义固件req_fix的返回值就是RequestsMethod类对象，所有req_fix等于RequestsMethod类对象
+            result = req_fix.request_all(req_method=case_method, req_url=case_url, req_mime=case_mime, case_data=case_data)
+            print(result.text)
+
+
+
+        # 判断sql语句的类型是否为select并且sql语句不为None，如果条件满足就调用DB类对象的select方法执行查询sql语句。
+        elif sql_type == "select" and sql_sentence is not None:
+            # DB类对象为自定固件db_fix
+            select_result = db_fix.select(sql_sentence)
+            # print("查询的结果为：", select_result)
+            # print("用例数据为：", case_data, type(case_data))
+            # print("更新的key为：", update_key)
+            # 将查询的结果更新到用例数据中
+            case_data[update_key] = select_result
+            # 将更新之后的用例数据发送给服务器
+            # 使用RequestsMethod类对象调用request_all方法发送请求，自定义固件req_fix的返回值就是RequestsMethod类对象，所有req_fix等于RequestsMethod类对象
+            result = req_fix.request_all(req_method=case_method, req_url=case_url, req_mime=case_mime, case_data=case_data)
+            print(result.text)
+        else:
+            # 使用RequestsMethod类对象调用request_all方法发送请求，自定义固件req_fix的返回值就是RequestsMethod类对象，所有req_fix等于RequestsMethod类对象
+            result = req_fix.request_all(req_method=case_method, req_url=case_url, req_mime=case_mime,case_data=case_data)
+            print(result.text)
+
+
+        # 断言
+        try:
+            for key in expect_data:
+                assert expect_data.get(key) == result.json().get(key)
+        except:
+            log.error("断言失败，期望数据为："+str(expect_data)+"服务器返回的数据为："+result.text)
+            raise AssertionError("断言失败")
+
+
+if __name__ == '__main__':
+    pytest.main()
\ No newline at end of file

login/log.log

+2023-11-02 11:45:57,905 - logging_demo.py[line:71] - ERROR: 错误
+2023-11-02 11:45:57,905 - logging_demo.py[line:73] - INFO: 详细
+2023-11-02 11:45:57,905 - logging_demo.py[line:74] - WARNING: 警告
+2023-11-02 11:45:57,905 - logging_demo.py[line:75] - CRITICAL: 致命

login/logging_demo.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_57
+# FileName:      logging_demo.py
+# Author:       xxxxxxx
+# Datetime:     2023/11/2 11:12
+# Description:
+# 
+# ---------------------------------------------------------------------------
+import logging
+
+
+# 设置显示的级别
+# logging.basicConfig(level=logging.NOTSET, format='%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s')
+#
+#
+# logging.debug("调试信息")
+# logging.info("info信息")
+# logging.warning("warning信息")
+# logging.error("error信息")
+# logging.critical("致命信息")
+
+
+# def my_logger():
+#     # 创建logger对象
+#     logger = logging.getLogger()
+#     # 设置日志写入到文件中的级别
+#     logger.level = logging.NOTSET  # 任何级别都可以写入，如果不设置，只是写入warning以上的级别
+#
+#     # 创建日志文件--FileHandler("日志文件的路径", mode="a", encoding="utf-8")
+#     handler = logging.FileHandler("./log.log", mode="a", encoding="utf-8")
+#     # 设置日志信息的格式
+#     format = logging.Formatter('%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s')
+#     # 将format添加到handler中
+#     handler.setFormatter(format)
+#     # 将handler添加到Logger对象中
+#     logger.addHandler(handler)
+#     return logger
+#
+# logger = my_logger()
+# # 使用logger写入日志
+# logger.error("错误")
+# logger.debug("调试")
+# logger.info("详细")
+# logger.warning("警告")
+# logger.critical("致命")
+
+
+def login_1():
+    # 1创建login对象
+    logger = logging.getLogger()
+    # 2设置日志级别
+    logger.level = logging.INFO
+
+    # 3创建日志路径
+    handle = logging.FileHandler('./log.log', mode='w', encoding='utf-8')
+
+    # 4设置日志内容格式
+    format = logging.Formatter('%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s')
+
+    # 5将格式添加到日志中
+    handle.setFormatter(format)
+
+    # 6将路径添加到对象
+    logger.addHandler(handle)
+
+    return logger
+
+logger = login_1()
+# 使用logger写入日志
+logger.error("错误")
+logger.debug("调试")
+logger.info("详细")
+logger.warning("警告")
+logger.critical("致命")
\ No newline at end of file

login/logging模块.md

+# logging模块
+# logging模块
+
+### 日志的级别
+
+logging模块中日志的级别：
+ ```python
+ logging.debug("debug级别")
+ logging.info("info级别")
+ logging.warning("warning警告级别")
+ logging.error("error错误级别")
+ logging.critical("critical致命级别")
+ ```
+
+  注意：
+    1：日志的级别：critical > error > warning > info > debug
+    2：低于warning级别的日志不会在控制台输出。
+        如果低于warning级别的日志需要在控制台显示，需要设置日志的级别
+        logging.basicConfig(level=logging.NOTSET)
+
+
+
+### 日志的输出格式
+
+` '%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s'`
+
+解释：
+            `asctime`：时间
+            `filename`：文件名称
+            `lineno`：日志所在的代码行号
+            `levelname`：日志级别
+            `message`：日志信息
+
+```python
+logging.basicConfig(level=logging.NOTSET, format="日志的格式")
+```
+
+### 日志保存到文件中
+
+步骤:
+
+- 需要创建Logger对象。
+          创建Loger对象：logging.getLogger()
+- 再创建一个Handler，用于将日志写入到文件中
+          创建Handler：logging.FileHandler("日志保存的路径", mode="w")
+          在这里需要设置日志的输出级别：handler对象.setLevel(日志的级别)
+- 创建Handler中日志的输出格式
+          首先定义日志的输出格式：`formatter对象 = logging.Formatter('%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s')`
+          再设置Handler的日志输出格式：Handler对象.setFormatter(formatter对象)
+- 最后将Handler对象添加到Logger中
+          logger.addHandler(handler对象)   
+
+```python
+# 创建Logger对象
+logger = logging.getLogger()
+
+# 设置日志保存到文件中的级别
+logger.level = logging.NOTSET
+
+# 创建handler
+# FileHandler(日志文件名称, mode="w", encoding="utf-8")
+handler = logging.FileHandler("my_Log.log", mode="w", encoding="utf-8")
+
+# 创建Formatter，主要是日志显示的格式
+formatter = logging.Formatter('%(levelname)s: %(message)s - %(asctime)s - %(filename)s[line:%(lineno)d]')
+
+# 将formatter添加到handler中
+handler.setFormatter(formatter)
+
+# 将handler添加到logger对象中
+logger.addHandler(handler)
+
+# 使用logger对象，添加日志信息
+logger.debug("debug级别")
+logger.info("info级别")
+logger.warning("warning级别")
+logger.error("error级别")
+logger.critical("critical级别")
+logger.fatal("fatal级别")
+```
+

login/login.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   login.py
+# FileName:      login.py
+# Author:       xxxxxxx
+# Datetime:     2023/11/2 11:31
+# Description:
+# 命名规范：文件名全小写+下划线，类名大驼峰，方法和变量小写+下划线连接，
+# 常量大写，变量和常量用名词，方法用动词
+# ---------------------------------------------------------------------------
+