Python+Requests+Pytest+YAML+Allure接口自动化框架

GitHub源码地址（详细注释）：源码
调试项目python自主搭建：附项目源码
一、项目介绍

本项目是基于 Python+Requests+Pytest+YAML+Allure 搭建的 接口自动化测试框架，用于对 REST API 举行测试。
框架的主要特点包括：
模

• 块化设计：采取 分层架构，包括 API 层、业务层、数据层、公共模块、测试用例层，加强可维护性。
  
• Pytest 测试框架：使用 Pytest 举行测试构造、实验、夹具管理，并提供强大的插件支持。
  
• Requests 举行 API 测试：封装 HTTP 请求，简化 API 调用流程。
  
• YAML 管理测试数据：测试数据与代码解耦，支持多环境测试。
  
• Allure 生成测试报告：提供清楚直观的测试报告，支持测试汗青分析。
  

二、目录布局

1. PytestDemo/
2. │── api/                  # 接口封装层，封装用户相关的 API
3. │   ├── user.py                         # 提供底层 API 访问接口，与后端 API 进行交互
4. │── common/               # 公共模块（日志、数据库操作、HTTP 请求封装）
5. │   ├── logger.py         # 日志管理
6. │   ├── mysql_operate.py  # 数据库操作
7. │   ├── read_data.py      # 读取 YAML 文件数据
8. │── config/               # 配置文件（环境变量、测试数据）
9. │   ├── setting.ini       # MySQL 环境配置
10. │── core/                 # requests 请求方法封装、关键字返回结果类
11. │   ├── rest_client.py    # 简化 HTTP 请求的发送，并提供日志记录功能
12. │   ├── result_base.py    # 结果基类，用于定义接口返回结果的标准结构
13. │── data/                 # 测试数据文件管理
14. │   ├── api_test_data.yml
15. │   ├── base_data.yml     
16. │   ├── scenario_test_data.yml     
17. │── log/                  # 日志文件
18. │   ├── 20250324.log     
19. │── operation/            # 业务层（对接口请求进行封装）
20. │   ├── user.py           # 业务api封装，供测试用例调用。
21. │── testcases/            # 测试用例
22. │   ├── report/           # Allure 测试报告
23. │   ├── api_test/         # 单接口 API 用例集
24. │   ├── scenario_test/    # 业务链 API 用例集
25. │── conftest.py           # Pytest 夹具（Fixture）
26. │── requirements.txt      # 依赖包清单
27. │── pytest.ini            # Pytest 配置文件

复制代码

三、框架分层详解

1. api/：接口封装层

1. import os  # 导入os模块，用于文件和目录操作
2. from core.rest_client import RestClient  # 从core模块导入RestClient类
3. from common.read_data import data  # 从common模块导入data类，用于读取数据
5. # 获取当前文件所在的目录的上一级目录路径
6. BASE_PATH = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
7. # 构造配置文件setting.ini的完整路径
8. data_file_path = os.path.join(BASE_PATH, "config", "setting.ini")
9. # 读取配置文件中的API根URL
10. api_root_url = data.load_ini(data_file_path)["host"]["api_root_url"]
13. class User(RestClient):  # 继承RestClient类，封装用户相关的接口
15.     def __init__(self, api_root_url, **kwargs):
16.         """
17.         初始化User类，调用父类的构造方法
18.         :param api_root_url: API的根URL
19.         :param kwargs: 其他可选参数
20.         """
21.         super(User, self).__init__(api_root_url, **kwargs)
23.     def list_all_users(self, **kwargs):
24.         """
25.         获取所有用户列表
26.         :param kwargs: 其他可选参数
27.         :return: GET请求返回的响应结果
28.         """
29.         return self.get("/users", **kwargs)
31.     def list_one_user(self, username, **kwargs):
32.         """
33.         获取指定用户名的用户信息
34.         :param username: 用户名
35.         :param kwargs: 其他可选参数
36.         :return: GET请求返回的响应结果
37.         """
38.         return self.get("/users/{}".format(username), **kwargs)
40.     def register(self, **kwargs):
41.         """
42.         用户注册
43.         :param kwargs: 包含注册所需参数
44.         :return: POST请求返回的响应结果
45.         """
46.         return self.post("/register", **kwargs)
48.     def login(self, **kwargs):
49.         """
50.         用户登录
51.         :param kwargs: 包含登录所需参数
52.         :return: POST请求返回的响应结果
53.         """
54.         return self.post("/login", **kwargs)
56.     def update(self, user_id, **kwargs):
57.         """
58.         更新用户信息
59.         :param user_id: 需要更新的用户ID
60.         :param kwargs: 包含更新内容
61.         :return: PUT请求返回的响应结果
62.         """
63.         return self.put("/update/user/{}".format(user_id), **kwargs)
65.     def delete(self, name, **kwargs):
66.         """
67.         删除用户
68.         :param name: 需要删除的用户名
69.         :param kwargs: 其他可选参数
70.         :return: POST请求返回的响应结果
71.         """
72.         return self.post("/delete/user/{}".format(name), **kwargs)
75. user = User(api_root_url)  # 创建User类的实例，并传入API根URL

复制代码

作用：
这一层直接与后端 API 交互，实现最基础的接口请求
不处理业务逻辑，只负责请求和返回数据，调用时只需传入参数
继承 RestClient 统一管理 HTTP 请求
2. 公共模块 (common/)

2.1 日志管理 (common/logger.py)

1. import logging  # 导入logging模块，用于记录日志
2. import time  # 导入time模块，用于获取当前时间
3. import os  # 导入os模块，用于文件和目录操作
5. # 获取当前文件所在的目录的上一级目录路径
6. BASE_PATH = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
8. # 定义日志文件存放的目录路径
9. LOG_PATH = os.path.join(BASE_PATH, "log")
11. # 如果日志目录不存在，则创建日志目录
12. if not os.path.exists(LOG_PATH):
13.     os.mkdir(LOG_PATH)
16. class Logger:
17.     """
18.     Logger类用于配置和管理日志记录
19.     """
21.     def __init__(self):
22.         """
23.         初始化Logger类，创建日志记录器
24.         """
25.         # 定义日志文件的完整路径，文件名为当前日期.log
26.         self.logname = os.path.join(LOG_PATH, "{}.log".format(time.strftime("%Y%m%d")))
27.         # 创建一个日志记录器实例，名称为"log"
28.         self.logger = logging.getLogger("log")
30.         # 设置日志记录器的级别为DEBUG，表示记录所有级别的日志
31.         self.logger.setLevel(logging.DEBUG)
33.         # 定义日志格式
34.         self.formater = logging.Formatter(
35.             '[%(asctime)s][%(filename)s %(lineno)d][%(levelname)s]: %(message)s'
36.         )
38.         # 创建一个日志文件处理器，用于将日志写入文件
39.         self.filelogger = logging.FileHandler(self.logname, mode='a', encoding="UTF-8")
41.         # 创建一个控制台处理器，用于在控制台输出日志
42.         self.console = logging.StreamHandler()
44.         # 设置控制台日志级别为DEBUG
45.         self.console.setLevel(logging.DEBUG)
47.         # 设置文件日志级别为DEBUG
48.         self.filelogger.setLevel(logging.DEBUG)
50.         # 为文件日志处理器和控制台日志处理器设置相同的日志格式
51.         self.filelogger.setFormatter(self.formater)
53.         # 设置控制台日志的格式
54.         self.console.setFormatter(self.formater)
56.         # 将文件日志处理器添加到日志记录器
57.         self.logger.addHandler(self.filelogger)
59.         # 将控制台日志处理器添加到日志记录器
60.         self.logger.addHandler(self.console)
63. # 创建Logger类的实例，并获取日志记录器
64. logger = Logger().logger
66. if __name__ == '__main__':
67.     logger.info("---测试开始---")  # 记录INFO级别日志
68.     logger.debug("---测试结束---")  # 记录DEBUG级别日志

复制代码

作用：
封装日志模块，记录测试实验过程。
使用方式：

1. from common.logger import logger
3. logger.info("这是一条测试日志")

复制代码

2.2 数据库操作（common/mysql_operate.py）

1. import pymysql  # 导入pymysql库，用于操作MySQL数据库
2. import os  # 导入os模块，用于路径操作
3. from common.read_data import data  # 从common模块中导入读取数据的方法
4. from common.logger import logger  # 从common模块中导入日志记录器
6. # 获取当前文件的上级目录路径
7. BASE_PATH = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
8. # 定义配置文件的路径
9. data_file_path = os.path.join(BASE_PATH, "config", "setting.ini")
10. # 读取配置文件中的 MySQL 配置信息
11. data = data.load_ini(data_file_path)["mysql"]
13. # 从配置文件中提取MySQL连接所需的参数，并存储在字典中
14. DB_CONF = {
15.     "host": data["MYSQL_HOST"],        # 数据库主机地址
16.     "port": int(data["MYSQL_PORT"]),   # 数据库端口号
17.     "user": data["MYSQL_USER"],        # 数据库用户名
18.     "password": data["MYSQL_PASSWD"],  # 数据库密码
19.     "db": data["MYSQL_DB"]             # 数据库名称
20. }
23. class MysqlDb():
24.     """
25.         MysqlDb 类用于封装 MySQL 数据库的连接和操作方法。
26.         """
28.     def __init__(self, db_conf=DB_CONF):
29.         """
30.         初始化MySQL连接
31.         :param db_conf: 数据库配置字典，包含连接MySQL所需的配置信息
32.         """
33.         # 通过字典拆包传递数据库配置信息，建立数据库连接
34.         self.conn = pymysql.connect(**db_conf, autocommit=False)
35.         # 通过 cursor() 方法创建游标对象，并让查询结果以字典格式输出
36.         self.cur = self.conn.cursor(cursor=pymysql.cursors.DictCursor)
38.     def __del__(self):
39.         """
40.         释放数据库资源，在对象被删除时自动调用
41.         """
42.         # 关闭游标
43.         self.cur.close()
44.         # 关闭数据库连接
45.         self.conn.close()
47.     def select_db(self, sql):
48.         """
49.         执行查询操作
50.         :param sql: 要执行的SQL查询语句
51.         :return: 查询结果（列表格式）
52.         """
53.         # 检查数据库连接是否断开，如果连接断开则重新建立连接
54.         self.conn.ping(reconnect=True)
55.         # 执行SQL查询
56.         self.cur.execute(sql)
57.         # 获取查询结果
58.         data = self.cur.fetchall()
59.         return data
61.     def execute_db(self, sql):
62.         """
63.         执行更新、插入或删除操作
64.         :param sql: 要执行的SQL语句（更新/插入/删除）
65.         """
66.         try:
67.             # 检查数据库连接是否断开，如果连接断开则重新建立连接
68.             self.conn.ping(reconnect=True)
69.             # 执行SQL语句
70.             self.cur.execute(sql)
71.             # 提交事务
72.             self.conn.commit()
73.         except Exception as e:
74.             # 捕获异常并记录错误日志
75.             logger.info("操作MySQL出现错误，错误原因：{}".format(e))
76.             # 如果发生异常，回滚事务
77.             self.conn.rollback()
80. # 创建MysqlDb对象并使用DB_CONF进行初始化
81. db = MysqlDb(DB_CONF)

复制代码

作用：
封装 MySQL 连接，支持数据查询、实验 SQL 语句。
使用方式：

1. db = MysqlDb()
2. data = db.select_db("SELECT * FROM user")

复制代码

2.3 读取设置文件（common/read_data.py）

1. import yaml  # 用于处理 YAML 文件
2. import json  # 用于处理 JSON 文件
3. from configparser import ConfigParser  # 用于处理 INI 配置文件
4. from common.logger import logger  # 导入日志记录器
7. class MyConfigParser(ConfigParser):
8.     """
9.     自定义的 ConfigParser 类，继承自 Python 内置的 ConfigParser。
10.     主要用于解决 .ini 文件中的键（option）自动转为小写的问题。
11.     """
12.     def __init__(self, defaults=None):
13.         # 调用父类 ConfigParser 的构造方法
14.         ConfigParser.__init__(self, defaults=defaults)
16.     def optionxform(self, optionstr):
17.         # 重写 optionxform 方法，使选项名称保持大小写不变
18.         return optionstr
21. class ReadFileData():
22.     """
23.     该类用于读取不同格式的文件数据，包括 YAML、JSON 和 INI 配置文件。
24.     """
25.     def __init__(self):
26.         pass  # 该类的构造方法无特殊初始化操作
28.     def load_yaml(self, file_path):
29.         """
30.         读取 YAML 文件并解析数据。
31.         :param file_path: YAML 文件的路径
32.         :return: 解析后的 YAML 数据
33.         """
34.         logger.info("加载 {} 文件......".format(file_path))  # 记录日志，指示正在加载 YAML 文件
35.         with open(file_path, encoding='utf-8') as f:
36.             data = yaml.safe_load(f)  # 使用 safe_load 方法解析 YAML 文件
37.         logger.info("读到数据 ==>>  {} ".format(data))  # 记录日志，输出读取的数据
38.         return data
40.     def load_json(self, file_path):
41.         """
42.         读取 JSON 文件并解析数据。
43.         :param file_path: JSON 文件的路径
44.         :return: 解析后的 JSON 数据
45.         """
46.         logger.info("加载 {} 文件......".format(file_path))  # 记录日志，指示正在加载 JSON 文件
47.         with open(file_path, encoding='utf-8') as f:
48.             data = json.load(f)  # 解析 JSON 文件
49.         logger.info("读到数据 ==>>  {} ".format(data))  # 记录日志，输出读取的数据
50.         return data
52.     def load_ini(self, file_path):
53.         """
54.         读取 INI 配置文件并解析数据。
55.         :param file_path: INI 配置文件的路径
56.         :return: 解析后的 INI 数据，转换为字典格式
57.         """
58.         logger.info("加载 {} 文件......".format(file_path))  # 记录日志，指示正在加载 INI 文件
59.         config = MyConfigParser()  # 创建 MyConfigParser 实例
60.         config.read(file_path, encoding="UTF-8")  # 读取 INI 配置文件
61.         data = dict(config._sections)  # 将配置文件的 sections 转换为字典格式
62.         # print("读到数据 ==>>  {} ".format(data))  # 该行被注释掉，避免调试输出
63.         return data
66. # 创建 ReadFileData 类的实例，以便在其他模块中直接使用 data 变量进行文件读取操作
67. data = ReadFileData()

复制代码

作用：
读取设置文件（如 setting.ini）、剖析 YAML 测试数据，并提供一个统一的接口，使其他模块可以轻松获取设置信息和测试数据。
3. config/：设置管理

1. [host]
2. # 测试环境
3. api_root_url = http://127.0.0.1:5000
5. [mysql]
6. # MySQL配置
7. MYSQL_HOST = localhost
8. MYSQL_PORT = 3306
9. MYSQL_USER = root
10. MYSQL_PASSWD = 123456
11. MYSQL_DB = flask_demo
12. autocommit: True  # 确保自动提交开启

复制代码

作用：
存储环境变量、数据库连接信息等
让设置可修改、可复用
4. core/：请求封装层

core/ 目录是请求封装层，主要负责：

• 封装 HTTP 请求方法，提供统一的 API 访问接口（rest_client.py）。
  
• 界说接口返回的标准格式，方便后续断言（result_base.py）。
  

4.1 rest_client.py：封装 HTTP 请求

1. import requests  # 导入requests库，用于发送HTTP请求
2. import json as complexjson  # 导入json模块并重命名为complexjson，避免与局部变量json冲突
3. from common.logger import logger  # 导入日志模块，用于记录HTTP请求日志
6. class RestClient():
7.     """
8.     RestClient类，封装HTTP请求的方法
9.     """
11.     def __init__(self, api_root_url):
12.         """
13.         初始化RestClient类
14.         :param api_root_url: API的根URL
15.         """
16.         self.api_root_url = api_root_url  # 设置API根URL
17.         self.session = requests.session()  # 创建一个requests的会话对象，提高请求效率
19.     def get(self, url, **kwargs):
20.         """
21.         发送GET请求
22.         :param url: API接口路径
23.         :param kwargs: 其他可选参数（如headers, params等）
24.         :return: GET请求的响应对象
25.         """
26.         return self.request(url, "GET", **kwargs)
28.     def post(self, url, data=None, json=None, **kwargs):
29.         """
30.         发送POST请求
31.         :param url: API接口路径
32.         :param data: 表单数据（可选）
33.         :param json: JSON格式数据（可选）
34.         :param kwargs: 其他可选参数（如headers等）
35.         :return: POST请求的响应对象
36.         """
37.         return self.request(url, "POST", data, json, **kwargs)
39.     def put(self, url, data=None, **kwargs):
40.         """
41.         发送PUT请求
42.         :param url: API接口路径
43.         :param data: 需要更新的数据
44.         :param kwargs: 其他可选参数（如headers等）
45.         :return: PUT请求的响应对象
46.         """
47.         return self.request(url, "PUT", data, **kwargs)
49.     def delete(self, url, **kwargs):
50.         """
51.         发送DELETE请求
52.         :param url: API接口路径
53.         :param kwargs: 其他可选参数（如headers等）
54.         :return: DELETE请求的响应对象
55.         """
56.         return self.request(url, "DELETE", **kwargs)
58.     def patch(self, url, data=None, **kwargs):
59.         """
60.         发送PATCH请求
61.         :param url: API接口路径
62.         :param data: 需要部分更新的数据
63.         :param kwargs: 其他可选参数（如headers等）
64.         :return: PATCH请求的响应对象
65.         """
66.         return self.request(url, "PATCH", data, **kwargs)
68.     def request(self, url, method, data=None, json=None, **kwargs):
69.         """
70.         统一的请求方法
71.         :param url: API接口路径
72.         :param method: 请求方法（GET, POST, PUT, DELETE, PATCH）
73.         :param data: 表单数据（可选）
74.         :param json: JSON格式数据（可选）
75.         :param kwargs: 其他可选参数（如headers, params等）
76.         :return: 请求的响应对象
77.         """
78.         url = self.api_root_url + url  # 拼接完整的URL
79.         headers = dict(**kwargs).get("headers")  # 获取请求头
80.         params = dict(**kwargs).get("params")  # 获取请求参数
81.         files = dict(**kwargs).get("files")  # 获取文件上传参数
82.         cookies = dict(**kwargs).get("cookies")  # 获取cookies参数
84.         # 记录请求日志
85.         self.request_log(url, method, data, json, params, headers, files, cookies)
87.         # 根据请求方法调用相应的requests方法
88.         if method == "GET":
89.             return self.session.get(url, **kwargs)
90.         if method == "POST":
91.             return requests.post(url, data=data, json=json, **kwargs)
92.         if method == "PUT":
93.             if json:
94.                 data = complexjson.dumps(json)  # 将json对象转换为字符串
95.             return self.session.put(url, data=data, **kwargs)
96.         if method == "DELETE":
97.             return self.session.delete(url, **kwargs)
98.         if method == "PATCH":
99.             if json:
100.                 data = complexjson.dumps(json)  # 将json对象转换为字符串
101.             return self.session.patch(url, data=data, **kwargs)
103.     def request_log(self, url, method, data=None, json=None, params=None, headers=None, files=None, cookies=None,
104.                     **kwargs):
105.         """
106.         记录HTTP请求日志，方便调试和问题排查
107.         :param url: 请求的URL
108.         :param method: 请求方法（GET, POST, PUT, DELETE, PATCH）
109.         :param data: 表单数据（可选）
110.         :param json: JSON格式数据（可选）
111.         :param params: URL查询参数（可选）
112.         :param headers: 请求头（可选）
113.         :param files: 上传的文件（可选）
114.         :param cookies: 请求的cookies（可选）
115.         :param kwargs: 其他可选参数
116.         """
117.         logger.info("接口请求地址 ==>> {}".format(url))
118.         logger.info("接口请求方式 ==>> {}".format(method))
119.         logger.info("接口请求头 ==>> {}".format(complexjson.dumps(headers, indent=4, ensure_ascii=False)))
120.         logger.info("接口请求 params 参数 ==>> {}".format(complexjson.dumps(params, indent=4, ensure_ascii=False)))
121.         logger.info("接口请求体 data 参数 ==>> {}".format(complexjson.dumps(data, indent=4, ensure_ascii=False)))
122.         logger.info("接口请求体 json 参数 ==>> {}".format(complexjson.dumps(json, indent=4, ensure_ascii=False)))
123.         logger.info("接口上传附件 files 参数 ==>> {}".format(files))
124.         logger.info("接口 cookies 参数 ==>> {}".format(complexjson.dumps(cookies, indent=4, ensure_ascii=False)))

复制代码

rest_client.py 封装了 GET、POST、PUT、DELETE 请求，提供一个 RestClient 类，让其他模块可以直接调用 HTTP 请求方法，而不必要每次都手写 requests.get() 或 requests.post()。
4.2 result_base.py：封装接口返回结果

1. class ResultBase:
2.     """
3.     结果基类，用于定义接口返回结果的标准结构。
4.     该类可以在后续扩展时添加通用的返回数据处理逻辑。
5.     """
6.     pass

复制代码

result_base.py 负责剖析接口返回的 JSON 数据，并提供统一的访问方式，让测试用例更加简洁。
5.data/：测试数据管理

作用：
让测试用例数据分离，便于维护
支持数据驱动，自动化测试多个场景
6. operation/：业务封装层

1. from core.result_base import ResultBase
2. from api.user import user
3. from common.logger import logger
5. def get_all_user_info():
6.     """
7.     获取全部用户信息
8.     :return: 自定义的关键字返回结果 result
9.     """
10.     result = ResultBase()  # 创建ResultBase对象，存储返回结果
11.     res = user.list_all_users()  # 调用API获取全部用户信息
12.     result.success = False  # 默认成功标志为False
13.     if res.json()["code"] == 0:  # 判断返回码是否为0
14.         result.success = True  # 如果返回码为0，表示成功
15.     else:
16.         result.error = "接口返回码是 【 {} 】, 返回信息：{} ".format(res.json()["code"], res.json()["msg"])  # 错误信息
17.     result.msg = res.json()["msg"]  # 记录返回消息
18.     result.response = res  # 记录完整的响应
19.     return result  # 返回封装的结果
21. def get_one_user_info(username):
22.     """
23.     获取单个用户信息
24.     :param username:  用户名
25.     :return: 自定义的关键字返回结果 result
26.     """
27.     result = ResultBase()  # 创建ResultBase对象
28.     res = user.list_one_user(username)  # 获取单个用户信息
29.     result.success = False  # 默认成功标志为False
30.     if res.json()["code"] == 0:
31.         result.success = True  # 成功时设置为True
32.     else:
33.         result.error = "查询用户 ==>> 接口返回码是 【 {} 】, 返回信息：{} ".format(res.json()["code"], res.json()["msg"])  # 错误信息
34.     result.msg = res.json()["msg"]
35.     result.response = res
36.     logger.info("查看单个用户 ==>> 返回结果 ==>> {}".format(result.response.text))  # 记录日志
37.     return result
39. def register_user(username, password, telephone, sex="", address=""):
40.     """
41.     注册用户信息
42.     :param username: 用户名
43.     :param password: 密码
44.     :param telephone: 手机号
45.     :param sex: 性别
46.     :param address: 联系地址
47.     :return: 自定义的关键字返回结果 result
48.     """
49.     result = ResultBase()  # 创建ResultBase对象
50.     json_data = {  # 请求体内容
51.         "username": username,
52.         "password": password,
53.         "sex": sex,
54.         "telephone": telephone,
55.         "address": address
56.     }
57.     header = {  # 请求头
58.         "Content-Type": "application/json"
59.     }
60.     res = user.register(json=json_data, headers=header)  # 调用API进行注册
61.     result.success = False  # 默认失败
62.     if res.json()["code"] == 0:
63.         result.success = True  # 注册成功时标记为True
64.     else:
65.         result.error = "接口返回码是 【 {} 】, 返回信息：{} ".format(res.json()["code"], res.json()["msg"])  # 错误信息
66.     result.msg = res.json()["msg"]
67.     result.response = res
68.     logger.info("注册用户 ==>> 返回结果 ==>> {}".format(result.response.text))  # 记录日志
69.     return result
71. def login_user(username, password):
72.     """
73.     登录用户
74.     :param username: 用户名
75.     :param password: 密码
76.     :return: 自定义的关键字返回结果 result
77.     """
78.     result = ResultBase()  # 创建ResultBase对象
79.     payload = {  # 登录请求参数
80.         "username": username,
81.         "password": password
82.     }
83.     header = {
84.         "Content-Type": "application/x-www-form-urlencoded"
85.     }
86.     res = user.login(data=payload, headers=header)  # 调用API进行登录
87.     result.success = False  # 默认失败
88.     if res.json()["code"] == 0:
89.         result.success = True  # 登录成功时标记为True
90.         # result.token = res.json()["login_info"]["token"]  # 存储登录令牌
91.     else:
92.         result.error = "接口返回码是 【 {} 】, 返回信息：{} ".format(res.json()["code"], res.json()["msg"])  # 错误信息
93.     result.msg = res.json()["msg"]
94.     result.response = res
95.     logger.info("登录用户 ==>> 返回结果 ==>> {}".format(result.response.text))  # 记录日志
96.     return result
98. def update_user(id, admin_user, new_password, new_telephone, token, new_sex="", new_address=""):
99.     """
100.     根据用户ID，修改用户信息
101.     :param id: 用户ID
102.     :param admin_user: 当前操作的管理员用户
103.     :param new_password: 新密码
104.     :param new_telephone: 新手机号
105.     :param token: 当前管理员用户的token
106.     :param new_sex: 新性别
107.     :param new_address: 新联系地址
108.     :return: 自定义的关键字返回结果 result
109.     """
110.     result = ResultBase()  # 创建ResultBase对象
111.     header = {
112.         "Content-Type": "application/json"
113.     }
114.     json_data = {  # 请求体内容
115.         "admin_user": admin_user,
116.         "password": new_password,
117.         "token": token,
118.         "sex": new_sex,
119.         "telephone": new_telephone,
120.         "address": new_address
121.     }
122.     res = user.update(id, json=json_data, headers=header)  # 调用API进行用户信息更新
123.     result.success = False  # 默认失败
124.     if res.json()["code"] == 0:
125.         result.success = True  # 更新成功时标记为True
126.     else:
127.         result.error = "接口返回码是 【 {} 】, 返回信息：{} ".format(res.json()["code"], res.json()["msg"])  # 错误信息
128.     result.msg = res.json()["msg"]
129.     result.response = res
130.     logger.info("修改用户 ==>> 返回结果 ==>> {}".format(result.response.text))  # 记录日志
131.     return result
133. def delete_user(username, admin_user, token):
134.     """
135.     根据用户名，删除用户信息
136.     :param username: 用户名
137.     :param admin_user: 当前操作的管理员用户
138.     :param token: 当前管理员用户的token
139.     :return: 自定义的关键字返回结果 result
140.     """
141.     result = ResultBase()  # 创建ResultBase对象
142.     json_data = {  # 请求体内容
143.         "admin_user": admin_user,
144.         "token": token,
145.     }
146.     header = {
147.         "Content-Type": "application/json"
148.     }
149.     res = user.delete(username, json=json_data, headers=header)  # 调用API进行用户删除
150.     result.success = False  # 默认失败
151.     if res.json()["code"] == 0:
152.         result.success = True  # 删除成功时标记为True
153.     else:
154.         result.error = "接口返回码是 【 {} 】, 返回信息：{} ".format(res.json()["code"], res.json()["msg"])  # 错误信息
155.     result.msg = res.json()["msg"]
156.     result.response = res
157.     logger.info("删除用户 ==>> 返回结果 ==>> {}".format(result.response.text))  # 记录日志
158.     return result

复制代码

业务api封装，供测试用例调用。
7. 测试报告展示

运行用例后，在项目根目录下，实验命令启动 allure 服务：

1. allure serve ./testcases/api_test/report

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。