本文档为业余时间汇总编写，基于书籍和实践过程中遇到的各种问题和解决方案，旨在为有类似需求的工程师提供一个完整、实用的框架搭建指南。
文档以电商平台为例，涵盖了从项目概述、环境搭建、测试框架使用、数据驱动测试、工具类实现、接口封装、测试用例编写、邮件报告发送、Jenkins持续集成到Docker容器化部署的完整流程。
通过分享实际项目中遇到的问题和解决思路，希望能帮助你快速搭建和维护一个高效、稳定的接口自动化测试框架，避免重复踩坑。
目录
「第一阶段：基础搭建（第1-3章）」
-
「第1章」：了解项目架构和技术选型
-
「第2章」：环境搭建和基础配置
-
「第3章」：pytest框架基础配置和异常处理
「第二阶段：核心能力（第4-6章）」
-
「第4章」：数据驱动测试（基础参数化 → YAML数据 → 动态钩子）
-
「第5章」：核心工具类实现（日志、路径、YAML处理）
-
「第6章」：接口封装与请求处理（基础API → 业务API → 优化处理）
「第三阶段：测试实践（第7章）」
-
「第7章」：测试用例编写（基础用例 → 参数化用例 → 动态钩子用例）
「第四阶段：报告与集成（第8-10章）」
-
「第8章」：邮件报告发送功能
-
「第9章」：Jenkins持续集成
-
「第10章」：Docker容器化部署
「第五阶段：问题解决（第11章）」
-
「第11章」：常见问题与最佳实践汇总
主要参考书籍
- 「《pytest框架与自动化测试应用》」
-
房荔枝、梁丽丽 清华大学出版社 9787302587156
-
- 「《接口自动化测试项目实战》」
-
江楚 清华大学出版社 9787302593751
-
- 「《接口自动化测试持续集成》」
-
Storm 人民邮电出版社 9787115503411
-
- 「《Python Web自动化测试入门与实战》」
-
杨定佳 清华大学出版社 9787302552956
-
1. 项目概述与架构设计
1.1 技术栈选择
| 类别 | 技术选择 | 版本 | 说明 |
|---|---|---|---|
| 「测试框架」 | pytest | 7.4.3+ | 测试用例管理和执行 |
| 「HTTP客户端」 | requests | 2.31.0+ | 接口请求发送 |
| 「数据处理」 | pyyaml | 6.0.1+ | YAML文件解析 |
| 「数据库连接」 | pymysql | 1.1.0+ | MySQL数据库连接 |
| 「报告生成」 | allure-pytest | 2.13.2+ | 测试报告生成 |
| 「邮件发送」 | smtplib | 内置 | 测试报告邮件发送 |
| 「CI/CD工具」 | Jenkins | 2.414+ | 持续集成和持续部署 |
| 「容器化」 | Docker | 20.10+ | 环境容器化 |
1.2 架构设计
1.2.1 执行流程时序图
1.3 目录结构
InterfaceAutomation/
├── api/ # 接口封装
│ ├── Web/ # Web端接口
│ │ └── web_login.py # Web登录接口
│ └── App/ # App端接口
│ └── app_login.py # App登录接口
├── config/ # 配置文件
│ ├── env.yaml # 环境配置
│ ├── test_params.yaml # 测试环境参数
│ └── prod_params.yaml # 生产环境参数
├── data/ # 测试数据
│ ├── Web/ # Web端测试数据
│ │ └── test_web_login.yaml
│ └── App/ # App端测试数据
│ └── test_app_login.yaml
├── reports/ # 测试报告
│ ├── allure_data/ # Allure报告数据
│ └── allure_report/ # Allure HTML报告
├── testcases/ # 测试用例
│ ├── Web/ # Web端测试用例
│ │ └── test_web_login.py
│ └── App/ # App端测试用例
│ └── test_app_login.py
├── utils/ # 工具类
│ ├── log_utils.py # 日志工具
│ ├── path_utils.py # 路径管理工具
│ ├── yaml_utils.py # YAML数据处理工具
│ ├── mysql_utils.py # MySQL连接工具
│ ├── request_utils.py # HTTP请求工具
│ ├── assert_utils.py # 断言工具
│ └── email_utils.py # 邮件发送工具
├── logs/ # 日志文件目录
├── conftest.py # pytest配置和fixtures
├── pytest.ini # pytest配置文件
├── requirements.txt # 依赖包
├── run.py # 运行入口
└── allure-config.yml # Allure报告配置
2. 环境搭建与配置
2.1 项目依赖安装
# 安装依赖
pip install -r requirements.txt
2.3 配置文件设置
2.3.1 环境配置
# config/env.yaml
common: # 通用配置
params:
test_params: test_params.yaml
prod_params: prod_params.yaml
test: # 测试环境配置
base_url: "https://test-api.example.com"
username: "test_user"
password: "test_password"
mysql: # host、port、user、password、database、charset···
redis: # host、port···
# 其他服务相关配置（根据实际项目，如Oracle、PostgreSQL、ClickHouse、ElasticSearch、RocketMQ配置等）
prod: # 生产环境配置
base_url: "https://api.example.com"
username: "prod_user"
password: "prod_password"
mysql: # host、port、user、password、database、charset···
redis: # host、port···
# 其他服务相关配置（根据实际项目，如Oracle、PostgreSQL、ClickHouse、ElasticSearch、RocketMQ配置等）
❝「注意」：为简化演示，本示例将密码等敏感信息直接写在配置文件中。在生产环境中，这是一种不安全的做法。建议使用环境变量、Jenkins Credentials、或专业的密钥管理工具来管理你的敏感数据，避免将其硬编码在代码或配置文件中。
❞
3. pytest测试框架
3.1 pytest配置文件
# pytest.ini
[pytest]
# 测试用例目录
testpaths = testcases
# 测试文件匹配模式
python_files = test_*.py
# 测试类匹配模式
python_classes = Test*
# 测试方法匹配模式
python_functions = test_*
# 标记配置
markers =
web: web接口测试
app: app接口测试
login: 登录相关测试
slow: 慢测试
smoke: 冒烟测试
3.2 异常处理与重试
3.2.1 异常处理
# testcases/test_exception.py
class TestException:
def test_exception_handling(self):
with pytest.raises(ValueError) as excinfo:
raise ValueError("测试异常")
assert "测试异常" in str(excinfo.value)
3.2.2 重试机制
# 安装pytest-rerunfailures插件
pip install pytest-rerunfailures
# 运行测试并设置重试次数
pytest --reruns 3 --reruns-delay 2
4. 数据驱动测试
❝「提示」：本章基于第3章的pytest基础配置，重点学习数据驱动的三种实现方式，从简单到复杂，为第7章的测试用例编写奠定基础。
❞
4.1 数据驱动实现方式
4.1.1 pytest参数化
# testcases/test_parametrize.py
import pytest
class TestLogin:
@pytest.mark.parametrize("username, password, expected_status", [
("valid_user", "valid_pass", 200),
("invalid_user", "valid_pass", 401),
("valid_user", "invalid_pass", 401),
("", "", 400)
])
def test_login(self, username, password, expected_status):
# 登录测试代码
response = self.login_api(username, password)
assert response.status_code == expected_status
4.1.2 YAML数据文件
❝「提示」：此处展示了直接在测试类中加载数据文件的一种基础方法。这种方法简单直观，但存在路径硬编码和代码重复的问题。在接下来的 「4.2.2 节」 中，将介绍一种基于Pytest钩子函数的、更强大且可扩展的动态数据驱动方案，这也是本框架最终推荐的实践方式。
❞
# data/Web/test_web_login.yaml
login_success:
- username: "valid_user"
password: "valid_pass"
expected_status: 200
expected_message: "登录成功"
login_failure:
- username: "invalid_user"
password: "valid_pass"
expected_status: 401
expected_message: "用户名或密码错误"
- username: "valid_user"
password: "invalid_pass"
expected_status: 401
expected_message: "用户名或密码错误"
- username: ""
password: ""
expected_status: 400
expected_message: "用户名和密码不能为空"
# testcases/test_yaml_data.py
import yaml
import os
class TestLoginWithYaml:
def setup_class(self):
# 加载YAML数据
with open(os.path.join(os.path.dirname(__file__), "../data/Web/test_web_login.yaml"), "r", encoding="utf-8") as f:
self.data = yaml.safe_load(f)
@pytest.mark.parametrize("case", self.data["login_success"])
def test_login_success(self, case):
response = self.login_api(case["username"], case["password"])
assert response.status_code == case["expected_status"]
assert case["expected_message"] in response.text
@pytest.mark.parametrize("case", self.data["login_failure"])
def test_login_failure(self, case):
response = self.login_api(case["username"], case["password"])
assert response.status_code == case["expected_status"]
assert case["expected_message"] in response.text
4.2 钩子函数（Hooks）的运用
pytest提供了丰富的钩子函数，允许在测试执行的不同阶段进行干预和定制。钩子函数是实现测试框架扩展和自定义行为的重要机制。
4.2.1 钩子函数概述
钩子函数是pytest框架提供的回调机制，允许插件和用户代码在测试执行的特定阶段执行自定义逻辑。主要分为以下几类：
-
「初始化钩子」：在pytest启动时执行
-
「收集钩子」：在收集测试用例时执行
-
「运行钩子」：在测试执行过程中执行
-
「报告钩子」：在生成报告时执行
4.2.2 常用钩子函数详解
4.2.2.1 pytest_addoption - 添加命令行参数
# conftest.py
def pytest_addoption(parser):
"""添加自定义命令行参数"""
parser.addoption(
"--env",
action="store",
default="test",
help="环境配置：test 或 prod"
)
parser.addoption(
"--browser",
action="store",
default="chrome",
help="浏览器类型：chrome, firefox, edge"
)
parser.addoption(
"--headless",
action="store_true",
help="是否使用无头模式运行浏览器"
)
「使用方式：」
# 运行测试时指定环境
pytest --env=prod
# 指定浏览器类型
pytest --browser=chrome --headless
4.2.2.2 pytest_generate_tests - 动态参数化
# conftest.py
def pytest_generate_tests(metafunc):
"""
动态生成测试参数，实现数据驱动的参数化测试
"""
# 检查测试方法是否需要 'case' 参数
if "case" in metafunc.fixturenames:
# 检查测试方法是否有自定义的 'data_key' marker
data_key_markers = list(
metafunc.definition.iter_markers(name="data_key"))
if data_key_markers:
# 获取 marker 中指定的数据键
data_key = data_key_markers[0].args[0]
# 获取当前测试模块的完整文件路径
module_file_path = metafunc.module.__file__
# 根据测试文件路径确定数据目录
data_base_dir = None
if "testcases/Web" in str(module_file_path).replace("\\", "/"):
data_base_dir = PathUtil.WEB_DATA_DIR
elif "testcases/App" in str(module_file_path).replace("\\", "/"):
data_base_dir = PathUtil.APP_DATA_DIR
else:
pytest.fail(f"无法确定测试数据目录：{module_file_path}")
# 构建YAML文件路径
file_name = PathUtil.get_filename_without_extension(
module_file_path) + ".yaml"
file_path = data_base_dir / file_name
# 获取当前环境参数
current_env = metafunc.config.getoption("env")
# 加载测试数据
try:
all_test_cases = load_yaml_data(
file_path=file_path, env=current_env)
except FileNotFoundError:
pytest.fail(f"测试数据文件未找到: {file_path}")
# 参数化测试
if all_test_cases and data_key in all_test_cases:
metafunc.parametrize(
"case",
all_test_cases[data_key],
ids=lambda x: x['case_id']
)
else:
pytest.fail(f"数据键 '{data_key}' 未在文件 '{file_path}' 中找到")
else:
pytest.fail(
f"测试方法需要 'case' 参数，但缺少 '@pytest.mark.data_key(\"your_key\")' 标记"
)
「在测试用例中使用：」
# testcases/test_login.py
import pytest
class TestLogin:
@pytest.mark.data_key("login_success")
def test_login_success(self, case):
"""测试登录成功场景"""
# case 参数会自动从 YAML 文件中加载
username = case["username"]
password = case["password"]
expected_status = case["expected_status"]
# 执行登录测试
response = self.login_api(username, password)
assert response.status_code == expected_status
4.2.2.3 pytest_runtest_setup/teardown - 测试前后处理
# conftest.py
def pytest_runtest_setup(item):
"""每个测试用例执行前的设置"""
logger.info(f"开始执行测试: {item.name}")
# 设置测试环境
if hasattr(item, 'funcargs'):
# 检查是否需要特定的测试环境
if 'web_driver' in item.funcargs:
logger.info("设置Web测试环境")
elif 'api_client' in item.funcargs:
logger.info("设置API测试环境")
def pytest_runtest_teardown(item, nextitem):
"""每个测试用例执行后的清理"""
logger.info(f"完成测试: {item.name}")
# 清理测试数据
if hasattr(item, 'funcargs'):
if 'web_driver' in item.funcargs:
# 清理浏览器缓存
pass
elif 'api_client' in item.funcargs:
# 清理API测试数据
pass
4.2.2.4 pytest_runtest_makereport - 测试报告定制
# conftest.py
@pytest.hookimpl(tryfirst=True, hookwrapper=True)
def pytest_runtest_makereport(item, call):
"""收集测试结果，用于生成详细的测试报告"""
outcome = yield
report = outcome.get_result()
# 只在测试执行阶段收集结果
if report.when == "call":
# 添加测试用例描述
if hasattr(item, 'funcargs') and 'case' in item.funcargs:
case = item.funcargs['case']
if 'description' in case:
report.description = case['description']
# 收集测试执行时间
report.duration = getattr(report, 'duration', 0)
# 收集失败信息
if report.failed:
# 添加失败截图（如果是Web测试）
if hasattr(item, 'funcargs') and 'web_driver' in item.funcargs:
driver = item.funcargs['web_driver']
screenshot_path = f"screenshots/{item.name}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png"
driver.save_screenshot(screenshot_path)
report.attachments.append(('screenshot', screenshot_path, 'image/png'))
4.2.2.5 pytest_collection_modifyitems - 测试用例收集后处理
# conftest.py
def pytest_collection_modifyitems(config, items):
"""修改收集到的测试用例"""
# 根据标记对测试用例进行排序
def get_priority(item):
# 获取测试用例的优先级标记
priority_markers = list(item.iter_markers(name="priority"))
if priority_markers:
return priority_markers[0].args[0]
return 999 # 默认优先级
# 按优先级排序
items.sort(key=get_priority)
# 为测试用例添加自定义属性
for item in items:
# 添加测试用例类型
if "web" in item.nodeid:
item.add_marker(pytest.mark.web)
elif "api" in item.nodeid:
item.add_marker(pytest.mark.api)
# 添加测试用例标签
if "smoke" in item.nodeid:
item.add_marker(pytest.mark.smoke)
elif "regression" in item.nodeid:
item.add_marker(pytest.mark.regression)
4.2.2.6 pytest_configure - 配置钩子
# conftest.py
def pytest_configure(config):
"""pytest配置钩子，在测试开始前执行"""
# 注册自定义标记
config.addinivalue_line(
"markers", "web: 标记为Web端测试"
)
config.addinivalue_line(
"markers", "api: 标记为API测试"
)
config.addinivalue_line(
"markers", "smoke: 标记为冒烟测试"
)
config.addinivalue_line(
"markers", "regression: 标记为回归测试"
)
config.addinivalue_line(
"markers", "priority(level): 设置测试优先级"
)
config.addinivalue_line(
"markers", "data_key(key): 指定测试数据键"
)
# 设置测试环境
env = config.getoption("env")
logger.info(f"测试环境: {env}")
# 初始化全局配置
global_config = load_global_config(env)
config._global_config = global_config
4.2.2.7 pytest_terminal_summary - 终端报告定制
# conftest.py
def pytest_terminal_summary(terminalreporter, exitstatus, config):
"""定制终端输出摘要"""
# 统计测试结果
total = len(terminalreporter.stats.get('passed', [])) + \
len(terminalreporter.stats.get('failed', [])) + \
len(terminalreporter.stats.get('skipped', []))
passed = len(terminalreporter.stats.get('passed', []))
failed = len(terminalreporter.stats.get('failed', []))
skipped = len(terminalreporter.stats.get('skipped', []))
# 计算通过率
pass_rate = (passed / total * 100) if total > 0 else 0
# 输出测试摘要
terminalreporter.write_sep("=", "测试执行摘要")
terminalreporter.write_line(f"总用例数: {total}")
terminalreporter.write_line(f"通过用例: {passed}")
terminalreporter.write_line(f"失败用例: {failed}")
terminalreporter.write_line(f"跳过用例: {skipped}")
terminalreporter.write_line(f"通过率: {pass_rate:.2f}%")
# 输出失败用例详情
if failed > 0:
terminalreporter.write_sep("-", "失败用例详情")
for report in terminalreporter.stats.get('failed', []):
terminalreporter.write_line(f" - {report.nodeid}")
if hasattr(report, 'longrepr'):
terminalreporter.write_line(f" 错误: {report.longrepr}")
5. 核心工具类实现
5.1 日志工具类（log_utils.py）
5.1.1 日志工具类设计
日志工具类提供了统一的日志记录功能，支持控制台彩色输出和文件滚动存储。
# utils/log_utils.py
import os
import logging
import colorlog
import glob
from datetime import datetime, timedelta
from logging.handlers import TimedRotatingFileHandler
from typing import Optional, TextIO
from utils.path_utils import PathUtil
# 日志根目录
LOG_DIR = PathUtil.LOGS_DIR
# 日志格式
LOG_FORMAT = "%(asctime)s [%(levelname)s] [%(filename)s:%(lineno)d] %(message)s"
# 自定义 TimedRotatingFileHandler，确保按天滚动日志
class DailyRotatingFileHandler(TimedRotatingFileHandler):
stream: Optional[TextIO]
def __init__(self, *args, **kwargs):
# 初始化时使用当前日期作为文件名
self.current_date = datetime.now().strftime('%Y-%m-%d')
log_dir = LOG_DIR if LOG_DIR is not None else os.getcwd()
filename = os.path.join(log_dir, f"{self.current_date}.log")
super().__init__(filename, when='midnight',
backupCount=7, encoding='utf-8', *args, **kwargs)
def shouldRollover(self, record):
"""检查是否需要滚动日志（日期变更时滚动）"""
current_date = datetime.now().strftime('%Y-%m-%d')
if current_date != self.current_date:
return True
return False
def doRollover(self):
"""执行日志滚动操作"""
# 关闭当前日志文件
if self.stream:
self.stream.close()
self.stream = None
# 更新当前日期
self.current_date = datetime.now().strftime('%Y-%m-%d')
log_dir = LOG_DIR if LOG_DIR is not None else os.getcwd()
self.baseFilename = os.path.join(log_dir, f"{self.current_date}.log")
# 清理过期日志文件（保留最近7天）
self._clean_old_logs()
# 打开新的日志文件
if not self.delay:
self.stream = self._open()
def _clean_old_logs(self):
"""清理超过保留期限的日志文件"""
now = datetime.now()
log_dir = LOG_DIR if LOG_DIR is not None else os.getcwd()
for log_file in glob.glob(os.path.join(log_dir, "*.log")):
try:
file_date_str = os.path.basename(log_file).split('.')[0]
file_date = datetime.strptime(file_date_str, '%Y-%m-%d')
# 删除超过7天的日志
if (now - file_date) > timedelta(days=self.backupCount):
os.remove(log_file)
except (ValueError, IndexError):
# 跳过格式不正确的文件名
continue
def setup_logger(name: Optional[str] = None, level: str = 'debug'):
"""配置并返回一个日志记录器，支持控制台和文件输出"""
logger = logging.getLogger(name or __name__)
logger.setLevel(logging.DEBUG)
# 避免重复添加处理器
if logger.hasHandlers():
return logger
# 控制台处理器（带颜色）
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.DEBUG)
console_formatter = colorlog.ColoredFormatter(
fmt="%(log_color)s" + LOG_FORMAT,
log_colors={
'DEBUG': 'cyan',
'INFO': 'green',
'WARNING': 'yellow',
'ERROR': 'red',
'CRITICAL': 'red,bg_white'
}
)
console_handler.setFormatter(console_formatter)
logger.addHandler(console_handler)
# 文件处理器（所有日志等级输出到文件）
file_handler = DailyRotatingFileHandler()
file_handler.setLevel(logging.DEBUG)
file_formatter = logging.Formatter(LOG_FORMAT)
file_handler.setFormatter(file_formatter)
logger.addHandler(file_handler)
return logger
# 提供一个模块级的默认 logger
default_logger = setup_logger(level='debug')
def get_module_logger(module_name: Optional[str] = None):
"""获取模块专用日志记录器"""
return setup_logger(module_name or __name__)
5.1.2 日志工具类使用
# 在测试用例中使用日志
from utils.log_utils import default_logger as logger
class TestLogin:
def test_login_success(self):
logger.info("开始执行登录测试")
try:
# 执行登录逻辑
response = self.login_api("test_user", "test_pass")
logger.info(f"登录成功，响应状态码: {response.status_code}")
assert response.status_code == 200
except Exception as e:
logger.error(f"登录测试失败: {str(e)}")
raise
5.2 路径工具类（path_utils.py）
5.2.1 路径工具类设计
路径工具类提供了统一的路径管理功能，自动识别项目根目录并管理各个子目录的路径。
# utils/path_utils.py
from pathlib import Path
from typing import Optional, Union
import sys
class PathUtil:
"""路径工具类，为项目各目录生成独立路径变量"""
# 项目根目录 (自动识别)
ROOT_PATH: Optional[Path] = None
# 核心目录
CONFIG_DIR: Optional[Path] = None # config/
API_DIR: Optional[Path] = None # api/
DATA_DIR: Optional[Path] = None # data/
TESTCASES_DIR: Optional[Path] = None # testcases/
UTILS_DIR: Optional[Path] = None # utils/
REPORTS_DIR: Optional[Path] = None # reports/
LOGS_DIR: Optional[Path] = None # logs/
# 数据目录子路径
WEB_DATA_DIR: Optional[Path] = None # data/Web/
APP_DATA_DIR: Optional[Path] = None # data/App/
# 测试用例目录子路径
WEB_TESTCASES_DIR: Optional[Path] = None # testcases/Web/
APP_TESTCASES_DIR: Optional[Path] = None # testcases/App/
# 报告子目录
ALLURE_DATA_DIR: Optional[Path] = None # reports/allure_data/
ALLURE_REPORT_DIR: Optional[Path] = None # reports/allure_report/
def __init__(self):
"""初始化路径变量"""
if PathUtil.ROOT_PATH is None:
PathUtil.ROOT_PATH = self.get_root_path()
# 初始化核心目录
PathUtil.CONFIG_DIR = self.get_resource_path("config")
PathUtil.API_DIR = self.get_resource_path("api")
PathUtil.DATA_DIR = self.get_resource_path("data")
PathUtil.TESTCASES_DIR = self.get_resource_path("testcases")
PathUtil.UTILS_DIR = self.get_resource_path("utils")
PathUtil.REPORTS_DIR = self.get_resource_path("reports")
PathUtil.LOGS_DIR = self.get_resource_path("logs")
# 初始化数据目录子路径
PathUtil.WEB_DATA_DIR = self.get_resource_path("data/Web")
PathUtil.APP_DATA_DIR = self.get_resource_path("data/App")
# 初始化测试用例目录子路径
PathUtil.WEB_TESTCASES_DIR = self.get_resource_path("testcases/Web")
PathUtil.APP_TESTCASES_DIR = self.get_resource_path("testcases/App")
# 初始化报告子目录
PathUtil.ALLURE_DATA_DIR = self.get_resource_path("reports/allure_data")
PathUtil.ALLURE_REPORT_DIR = self.get_resource_path("reports/allure_report")
@staticmethod
def get_root_path(marker_file: str = "run.py") -> Path:
"""自动识别项目根目录（单例模式）"""
if PathUtil.ROOT_PATH is not None:
return PathUtil.ROOT_PATH
if getattr(sys, 'frozen', False):
base_path = Path(sys._MEIPASS)
else:
current_path = Path(__file__).resolve()
while current_path != current_path.parent:
if (current_path / marker_file).exists():
base_path = current_path
break
current_path = current_path.parent
else:
raise FileNotFoundError(f"未找到项目根目录标记文件：{marker_file}")
PathUtil.ROOT_PATH = base_path
return base_path
@staticmethod
def get_resource_path(relative_path: Union[str, Path]) -> Path:
"""从根目录构建资源路径并确保存在"""
if PathUtil.ROOT_PATH is None:
raise RuntimeError("ROOT_PATH 未初始化，请先调用 PathUtil() 初始化")
path = PathUtil.ROOT_PATH / relative_path
PathUtil.ensure_dir(path)
return path.resolve()
@staticmethod
def ensure_dir(path: Path) -> None:
"""确保目录存在"""
path.mkdir(parents=True, exist_ok=True)
@staticmethod
def ensure_extension(path: Union[str, Path], ext: str) -> Path:
"""确保路径以指定扩展名结尾"""
p = Path(path)
return p.with_suffix(ext) if p.suffix != ext else p
@staticmethod
def list_files(directory: Path, pattern: str = "*") -> list[Path]:
"""列出目录下匹配模式的文件"""
return sorted(directory.glob(pattern))
@staticmethod
def get_filename_without_extension(file_path: Union[str, Path]) -> str:
"""从文件路径中获取不带扩展名的文件名"""
path_obj = Path(file_path)
return path_obj.stem
# 自动初始化路径变量
_path_initializer = PathUtil()
del _path_initializer
5.2.2 路径工具类使用
# 在测试用例中使用路径工具
from utils.path_utils import PathUtil
class TestDataLoading:
def test_load_test_data(self):
# 获取测试数据文件路径
data_file = PathUtil.WEB_DATA_DIR / "test_web_login.yaml"
# 确保目录存在
PathUtil.ensure_dir(PathUtil.WEB_DATA_DIR)
# 获取不带扩展名的文件名
file_name = PathUtil.get_filename_without_extension(data_file)
print(f"文件名: {file_name}") # 输出: test_login
5.3 YAML工具类（yaml_utils.py）
5.3.1 YAML工具类设计
YAML工具类提供了YAML文件的读取和参数替换功能，支持环境变量占位符的动态替换。
# utils/yaml_utils.py
import yaml
from utils.path_utils import PathUtil
import re
def load_yaml_data(file_path, env):
"""读取 YAML 文件中的测试用例数据并替换环境参数占位符"""
# 加载测试用例数据
with open(file_path, "r", encoding="utf-8") as f:
test_cases = yaml.safe_load(f)["test_cases"]
# 加载环境参数配置
if PathUtil.CONFIG_DIR is None:
raise RuntimeError("PathUtil.CONFIG_DIR 未初始化，请检查路径工具模块的初始化。")
env_params_path = PathUtil.CONFIG_DIR / f"{env}_params.yaml"
with open(env_params_path, "r", encoding="utf-8") as f:
env_params = yaml.safe_load(f)
# 替换占位符
def replace_placeholders(data, params):
if isinstance(data, dict):
return {k: replace_placeholders(v, params) for k, v in data.items()}
elif isinstance(data, list):
return [replace_placeholders(item, params) for item in data]
elif isinstance(data, str):
pattern = re.compile(r"\$\{([^}]+)\}")
matches = pattern.findall(data)
if matches:
# 完全等于一个占位符，返回原始类型
if data == f"${{{matches[0]}}}" and len(matches) == 1:
return params.get(matches[0], data)
# 多个占位符且完全拼接，返回原始类型的列表
expected = "".join([f"${{{m}}}" for m in matches])
if data == expected and len(matches) > 1:
return [params.get(m, f"${{{m}}}") for m in matches]
# 其他情况，字符串模板替换
def repl(m):
return str(params.get(m.group(1), m.group(0)))
return pattern.sub(repl, data)
return data
return data
return replace_placeholders(test_cases, env_params)
5.3.2 YAML工具类使用
# 测试数据文件示例 (data/Web/test_web_login.yaml)
test_cases:
login_success:
- case_id: "login_success_001"
description: "正常登录测试"
params:
username: "${USERNAME}"
password: "${PASSWORD}"
expected:
status_code: 200
message: "登录成功"
# 环境参数文件示例 (config/test_params.yaml)
USERNAME: "test_user"
PASSWORD: "test_pass"
# 在测试用例中使用
from utils.yaml_utils import load_yaml_data
class TestLogin:
def test_login_with_data(self):
# 加载测试数据，自动替换占位符
test_data = load_yaml_data("data/Web/test_web_login.yaml", "test")
# 使用替换后的数据
case = test_data["login_success"][0]
username = case["params"]["username"] # 实际值: "test_user"
password = case["params"]["password"] # 实际值: "test_pass"
# 执行测试
response = self.login_api(username, password)
assert response.status_code == case["expected"]["status_code"]
5.4 MySQL工具类（mysql_utils.py）
5.4.1 MySQL工具类设计
MySQL工具类提供了数据库连接、查询、事务管理等功能，支持连接池和自动重连机制。
# utils/mysql_utils.py
import pymysql
import logging
from typing import List, Dict, Any, Optional, Tuple
from contextlib import contextmanager
from pymysql.cursors import DictCursor
import time
import threading
class MySQLUtils:
"""MySQL数据库工具类"""
def __init__(self, host: str, port: int, user: str, password: str,
database: str, charset: str = 'utf8mb4',
max_connections: int = 10, timeout: int = 30):
"""
初始化MySQL连接配置
Args:
host: 数据库主机地址
port: 数据库端口
user: 数据库用户名
password: 数据库密码
database: 数据库名称
charset: 字符集编码
max_connections: 最大连接数
timeout: 连接超时时间
"""
self.host = host
self.port = port
self.user = user
self.password = password
self.database = database
self.charset = charset
self.max_connections = max_connections
self.timeout = timeout
# 连接池
self._connection_pool = []
self._pool_lock = threading.Lock()
self.logger = logging.getLogger(__name__)
# 初始化连接池
self._init_connection_pool()
def _init_connection_pool(self):
"""初始化连接池"""
try:
for _ in range(self.max_connections):
conn = self._create_connection()
if conn:
self._connection_pool.append(conn)
self.logger.info(f"MySQL连接池初始化完成，连接数: {len(self._connection_pool)}")
except Exception as e:
self.logger.error(f"初始化MySQL连接池失败: {str(e)}")
raise
def _create_connection(self) -> Optional[pymysql.Connection]:
"""创建数据库连接"""
try:
connection = pymysql.connect(
host=self.host,
port=self.port,
user=self.user,
password=self.password,
database=self.database,
charset=self.charset,
cursorclass=DictCursor,
autocommit=False,
connect_timeout=self.timeout
)
return connection
except Exception as e:
self.logger.error(f"创建MySQL连接失败: {str(e)}")
return None
def _get_connection(self) -> Optional[pymysql.Connection]:
"""从连接池获取连接"""
with self._pool_lock:
if self._connection_pool:
return self._connection_pool.pop()
else:
# 连接池为空，创建新连接
return self._create_connection()
def _return_connection(self, connection: pymysql.Connection):
"""归还连接到连接池"""
if connection:
try:
# 检查连接是否有效
connection.ping(reconnect=True)
with self._pool_lock:
if len(self._connection_pool) < self.max_connections:
self._connection_pool.append(connection)
else:
connection.close()
except Exception as e:
self.logger.warning(f"归还连接失败，关闭连接: {str(e)}")
try:
connection.close()
except:
pass
@contextmanager
def get_connection(self):
"""获取数据库连接的上下文管理器"""
connection = None
try:
connection = self._get_connection()
if not connection:
raise Exception("无法获取数据库连接")
yield connection
except Exception as e:
if connection:
connection.rollback()
self.logger.error(f"数据库操作失败: {str(e)}")
raise
finally:
if connection:
self._return_connection(connection)
def execute_query(self, sql: str, params: Optional[Tuple] = None) -> List[Dict[str, Any]]:
"""执行查询语句"""
with self.get_connection() as conn:
with conn.cursor() as cursor:
cursor.execute(sql, params)
result = cursor.fetchall()
self.logger.debug(f"执行查询: {sql}, 参数: {params}, 结果行数: {len(result)}")
return result
def execute_update(self, sql: str, params: Optional[Tuple] = None) -> int:
"""执行更新语句"""
with self.get_connection() as conn:
with conn.cursor() as cursor:
affected_rows = cursor.execute(sql, params)
conn.commit()
self.logger.debug(f"执行更新: {sql}, 参数: {params}, 影响行数: {affected_rows}")
return affected_rows
def execute_many(self, sql: str, params_list: List[Tuple]) -> int:
"""批量执行SQL语句"""
with self.get_connection() as conn:
with conn.cursor() as cursor:
affected_rows = cursor.executemany(sql, params_list)
conn.commit()
self.logger.debug(f"批量执行: {sql}, 参数数量: {len(params_list)}, 影响行数: {affected_rows}")
return affected_rows
def execute_transaction(self, sql_list: List[Tuple[str, Optional[Tuple]]]) -> bool:
"""执行事务"""
with self.get_connection() as conn:
try:
with conn.cursor() as cursor:
for sql, params in sql_list:
cursor.execute(sql, params)
conn.commit()
self.logger.info(f"事务执行成功，SQL数量: {len(sql_list)}")
return True
except Exception as e:
conn.rollback()
self.logger.error(f"事务执行失败: {str(e)}")
return False
def table_exists(self, table_name: str) -> bool:
"""检查表是否存在"""
sql = """
SELECT COUNT(*) as count
FROM information_schema.tables
WHERE table_schema = %s AND table_name = %s
"""
result = self.execute_query(sql, (self.database, table_name))
return result[0]['count'] > 0
def get_table_structure(self, table_name: str) -> List[Dict[str, Any]]:
"""获取表结构"""
sql = f"DESCRIBE {table_name}"
return self.execute_query(sql)
def backup_table(self, table_name: str, backup_table_name: str) -> bool:
"""备份表"""
try:
# 创建备份表
create_sql = f"CREATE TABLE {backup_table_name} LIKE {table_name}"
self.execute_update(create_sql)
# 复制数据
copy_sql = f"INSERT INTO {backup_table_name} SELECT * FROM {table_name}"
self.execute_update(copy_sql)
self.logger.info(f"表 {table_name} 备份成功，备份表: {backup_table_name}")
return True
except Exception as e:
self.logger.error(f"备份表 {table_name} 失败: {str(e)}")
return False
def restore_table(self, table_name: str, backup_table_name: str) -> bool:
"""恢复表"""
try:
# 删除原表
drop_sql = f"DROP TABLE IF EXISTS {table_name}"
self.execute_update(drop_sql)
# 恢复表结构
create_sql = f"CREATE TABLE {table_name} LIKE {backup_table_name}"
self.execute_update(create_sql)
# 恢复数据
copy_sql = f"INSERT INTO {table_name} SELECT * FROM {backup_table_name}"
self.execute_update(copy_sql)
self.logger.info(f"表 {table_name} 恢复成功")
return True
except Exception as e:
self.logger.error(f"恢复表 {table_name} 失败: {str(e)}")
return False
def close_all_connections(self):
"""关闭所有连接"""
with self._pool_lock:
for conn in self._connection_pool:
try:
conn.close()
except:
pass
self._connection_pool.clear()
self.logger.info("所有MySQL连接已关闭")
5.4.2 MySQL工具类使用
# 在测试用例中使用MySQL工具类
from utils.mysql_utils import MySQLUtils
import os
class TestDatabaseOperations:
def setup_class(self):
# 从配置文件加载数据库配置
config_path = os.path.join(os.path.dirname(__file__), "../config/env.yaml")
with open(config_path, "r", encoding="utf-8") as f:
import yaml
config = yaml.safe_load(f)
db_config = config["test"]["mysql"]
# 初始化MySQL工具类
self.mysql_utils = MySQLUtils(
host=db_config["host"],
port=db_config["port"],
user=db_config["user"],
password=db_config["password"],
database=db_config["database"]
)
def test_query_user_data(self):
"""测试查询用户数据"""
# 查询用户信息
sql = "SELECT id, username, email, created_at FROM users WHERE status = %s"
users = self.mysql_utils.execute_query(sql, ("active",))
# 验证查询结果
assert len(users) > 0
assert "id" in users[0]
assert "username" in users[0]
def test_insert_user_data(self):
"""测试插入用户数据"""
# 插入测试用户
insert_sql = """
INSERT INTO users (username, email, password, status, created_at)
VALUES (%s, %s, %s, %s, NOW())
"""
params = ("test_user", "test@example.com", "hashed_password", "active")
affected_rows = self.mysql_utils.execute_update(insert_sql, params)
assert affected_rows == 1
# 验证插入结果
select_sql = "SELECT * FROM users WHERE username = %s"
result = self.mysql_utils.execute_query(select_sql, ("test_user",))
assert len(result) == 1
assert result[0]["email"] == "test@example.com"
def test_batch_insert(self):
"""测试批量插入数据"""
# 准备批量插入数据
users_data = [
("user1", "user1@example.com", "pass1", "active"),
("user2", "user2@example.com", "pass2", "active"),
("user3", "user3@example.com", "pass3", "inactive")
]
insert_sql = """
INSERT INTO users (username, email, password, status, created_at)
VALUES (%s, %s, %s, %s, NOW())
"""
affected_rows = self.mysql_utils.execute_many(insert_sql, users_data)
assert affected_rows == 3
def test_transaction_operations(self):
"""测试事务操作"""
# 定义事务操作
transaction_operations = [
("INSERT INTO users (username, email, status) VALUES (%s, %s, %s)",
("transaction_user", "transaction@example.com", "active")),
("UPDATE users SET status = %s WHERE username = %s",
("inactive", "transaction_user")),
("DELETE FROM users WHERE username = %s",
("transaction_user",))
]
# 执行事务
success = self.mysql_utils.execute_transaction(transaction_operations)
assert success is True
def test_table_operations(self):
"""测试表操作"""
# 检查表是否存在
exists = self.mysql_utils.table_exists("users")
assert exists is True
# 获取表结构
structure = self.mysql_utils.get_table_structure("users")
assert len(structure) > 0
assert "Field" in structure[0]
def test_backup_and_restore(self):
"""测试表备份和恢复"""
# 备份表
backup_success = self.mysql_utils.backup_table("users", "users_backup")
assert backup_success is True
# 验证备份表存在
backup_exists = self.mysql_utils.table_exists("users_backup")
assert backup_exists is True
# 恢复表（这里只是演示，实际测试中可能需要更谨慎）
# restore_success = self.mysql_utils.restore_table("users", "users_backup")
# assert restore_success is True
def teardown_class(self):
"""清理测试数据"""
# 删除测试数据
cleanup_sql = "DELETE FROM users WHERE username LIKE %s"
self.mysql_utils.execute_update(cleanup_sql, ("test_%",))
# 删除备份表
drop_sql = "DROP TABLE IF EXISTS users_backup"
self.mysql_utils.execute_update(drop_sql)
# 关闭所有连接
self.mysql_utils.close_all_connections()
5.5 工具类集成使用
5.5.1 在测试框架中的集成
# conftest.py 中的工具类集成
import pytest
from utils.log_utils import default_logger as logger
from utils.path_utils import PathUtil
from utils.yaml_utils import load_yaml_data
from utils.mysql_utils import MySQLUtils
def pytest_generate_tests(metafunc):
"""动态生成测试参数"""
if "case" in metafunc.fixturenames:
data_key_markers = list(
metafunc.definition.iter_markers(name="data_key"))
if data_key_markers:
data_key = data_key_markers[0].args[0]
module_file_path = metafunc.module.__file__
# 使用路径工具确定数据目录
data_base_dir = None
if "testcases/Web" in str(module_file_path).replace("\\", "/"):
data_base_dir = PathUtil.WEB_DATA_DIR
elif "testcases/App" in str(module_file_path).replace("\\", "/"):
data_base_dir = PathUtil.APP_DATA_DIR
else:
pytest.fail(f"无法确定测试数据目录：{module_file_path}")
# 构建数据文件路径
file_name = PathUtil.get_filename_without_extension(
module_file_path) + ".yaml"
file_path = data_base_dir / file_name
# 获取当前环境
current_env = metafunc.config.getoption("env")
try:
# 使用YAML工具加载数据
all_test_cases = load_yaml_data(
file_path=file_path, env=current_env)
logger.info(f"成功加载测试数据: {file_path}")
except FileNotFoundError:
logger.error(f"测试数据文件未找到: {file_path}")
pytest.fail(f"测试数据文件未找到: {file_path}")
except Exception as e:
logger.error(f"加载测试数据失败: {e}")
pytest.fail(f"加载测试数据失败: {e}")
# 参数化测试
if all_test_cases and data_key in all_test_cases:
metafunc.parametrize(
"case",
all_test_cases[data_key],
ids=lambda x: x.get('case_id', 'unknown')
)
logger.info(f"成功参数化测试: {data_key}")
else:
logger.error(f"数据键 '{data_key}' 未在文件 '{file_path}' 中找到")
pytest.fail(f"数据键 '{data_key}' 未在文件 '{file_path}' 中找到")
@pytest.fixture(scope="session")
def mysql_utils(config):
"""MySQL数据库工具类fixture"""
try:
db_config = config["mysql"]
mysql_utils = MySQLUtils(
host=db_config["host"],
port=db_config["port"],
user=db_config["user"],
password=db_config["password"],
database=db_config["database"],
charset=db_config.get("charset", "utf8mb4")
)
logger.info("MySQL工具类初始化成功")
yield mysql_utils
except Exception as e:
logger.error(f"MySQL工具类初始化失败: {str(e)}")
pytest.fail(f"MySQL工具类初始化失败: {str(e)}")
finally:
# 清理连接
if 'mysql_utils' in locals():
mysql_utils.close_all_connections()
6. 接口封装与请求处理
6.1 接口封装设计
6.1.1 基础API类
# api/base_api.py
import requests
import logging
from typing import Dict, Any, Optional, Union
class BaseAPI:
def __init__(self, base_url: str, timeout: int = 10):
self.base_url = base_url
self.timeout = timeout
self.session = requests.Session()
self.logger = logging.getLogger(__name__)
def _request(self,
method: str,
endpoint: str,
params: Optional[Dict[str, Any]] = None,
data: Optional[Dict[str, Any]] = None,
json: Optional[Dict[str, Any]] = None,
headers: Optional[Dict[str, str]] = None,
files: Optional[Dict[str, Any]] = None,
auth: Optional[Union[tuple, requests.auth.AuthBase]] = None,
verify: bool = True,
proxies: Optional[Dict[str, str]] = None) -> requests.Response:
"""基础请求方法"""
url = f"{self.base_url}{endpoint}"
self.logger.info(f"发送{method}请求: {url}")
self.logger.debug(f"请求参数: {params}")
self.logger.debug(f"请求数据: {data}")
self.logger.debug(f"请求头: {headers}")
try:
response = self.session.request(
method=method,
url=url,
params=params,
data=data,
json=json,
headers=headers,
files=files,
auth=auth,
verify=verify,
proxies=proxies,
timeout=self.timeout
)
self.logger.info(f"请求响应状态码: {response.status_code}")
self.logger.debug(f"响应内容: {response.text}")
return response
except requests.exceptions.RequestException as e:
self.logger.error(f"请求异常: {str(e)}")
raise
def get(self, endpoint: str, **kwargs) -> requests.Response:
"""GET请求"""
return self._request("GET", endpoint, **kwargs)
def post(self, endpoint: str, **kwargs) -> requests.Response:
"""POST请求"""
return self._request("POST", endpoint, **kwargs)
def put(self, endpoint: str, **kwargs) -> requests.Response:
"""PUT请求"""
return self._request("PUT", endpoint, **kwargs)
def delete(self, endpoint: str, **kwargs) -> requests.Response:
"""DELETE请求"""
return self._request("DELETE", endpoint, **kwargs)
6.1.2 业务API类
# api/web_api.py
from api.base_api import BaseAPI
from typing import Dict, Any, Optional
class WebAPI(BaseAPI):
def __init__(self, base_url: str, timeout: int = 10):
super().__init__(base_url, timeout)
# Web API特有的初始化
self.headers = {
"Content-Type": "application/json",
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36"
}
def login(self, username: str, password: str) -> Dict[str, Any]:
"""登录接口"""
endpoint = "/login"
data = {
"username": username,
"password": password
}
response = self.post(endpoint, json=data, headers=self.headers)
response.raise_for_status() # 如果状态码不是200，抛出异常
return response.json()
def get_user_info(self, token: str) -> Dict[str, Any]:
"""获取用户信息接口"""
endpoint = "/user/info"
headers = self.headers.copy()
headers["Authorization"] = f"Bearer {token}"
response = self.get(endpoint, headers=headers)
response.raise_for_status()
return response.json()
def create_order(self, token: str, product_id: int, quantity: int) -> Dict[str, Any]:
"""创建订单接口"""
endpoint = "/orders"
headers = self.headers.copy()
headers["Authorization"] = f"Bearer {token}"
data = {
"product_id": product_id,
"quantity": quantity
}
response = self.post(endpoint, json=data, headers=headers)
response.raise_for_status()
return response.json()
6.2 请求处理优化
6.2.1 会话管理
# api/base_api.py (扩展)
class BaseAPI:
# ... 已有代码 ...
def __init__(self, base_url: str, timeout: int = 10):
self.base_url = base_url
self.timeout = timeout
self.session = requests.Session()
# 复用连接
self.session.keep_alive = True
# 设置连接池大小
self.session.mount("http://", requests.adapters.HTTPAdapter(pool_connections=10, pool_maxsize=10))
self.session.mount("https://", requests.adapters.HTTPAdapter(pool_connections=10, pool_maxsize=10))
self.logger = logging.getLogger(__name__)
6.3 请求参数处理
6.3.1 参数校验
# utils/param_utils.py
from typing import Dict, Any, List, Optional
from pydantic import BaseModel, ValidationError
class ParamValidator:
@staticmethod
def validate_params(params: Dict[str, Any], required_params: List[str]) -> None:
"""验证必填参数"""
missing_params = [param for param in required_params if param not in params]
if missing_params:
raise ValueError(f"缺少必填参数: {', '.join(missing_params)}")
@staticmethod
def validate_param_type(params: Dict[str, Any], type_spec: Dict[str, type]) -> None:
"""验证参数类型"""
for param, expected_type in type_spec.items():
if param in params and not isinstance(params[param], expected_type):
raise TypeError(f"参数{param}应为{expected_type.__name__}类型，实际为{type(params[param]).__name__}类型")
@staticmethod
def validate_with_model(params: Dict[str, Any], model_class: BaseModel) -> BaseModel:
"""使用Pydantic模型验证参数"""
try:
return model_class(**params)
except ValidationError as e:
raise ValueError(f"参数验证失败: {str(e)}")
6.3.2 参数格式化
# utils/param_utils.py (扩展)
class ParamFormatter:
@staticmethod
def format_date(params: Dict[str, Any], date_fields: List[str], format_str: str = "%Y-%m-%d") -> Dict[str, Any]:
"""格式化日期参数"""
from datetime import datetime
result = params.copy()
for field in date_fields:
if field in result:
try:
# 尝试将字符串转换为日期对象
if isinstance(result[field], str):
result[field] = datetime.strptime(result[field], format_str).date()
# 尝试将日期对象格式化为字符串
elif hasattr(result[field], "strftime"):
result[field] = result[field].strftime(format_str)
except Exception as e:
raise ValueError(f"日期字段{field}格式化失败: {str(e)}")
return result
@staticmethod
def remove_none_params(params: Dict[str, Any]) -> Dict[str, Any]:
"""移除值为None的参数"""
return {k: v for k, v in params.items() if v is not None}
6.4 响应处理
6.4.1 响应解析
# utils/response_utils.py
import json
from typing import Dict, Any, Optional
import logging
class ResponseParser:
@staticmethod
def parse_json(response_text: str) -> Dict[str, Any]:
"""解析JSON响应"""
try:
return json.loads(response_text)
except json.JSONDecodeError as e:
logging.error(f"JSON解析失败: {str(e)}, 响应内容: {response_text}")
raise
@staticmethod
def get_value_from_json(json_data: Dict[str, Any], path: str, default: Any = None) -> Any:
"""从JSON数据中获取指定路径的值"""
# 路径格式: "key1.key2[0].key3"
keys = path.split(".")
current = json_data
try:
for key in keys:
# 处理数组索引
if '[' in key and ']' in key:
key_name = key[:key.index('[')]
index = int(key[key.index('[')+1:key.index(']')])
current = current[key_name][index]
else:
current = current[key]
return current
except (KeyError, IndexError, TypeError):
logging.warning(f"无法从路径{path}获取值，返回默认值{default}")
return default
6.4.2 断言工具
# utils/assert_utils.py
from typing import Dict, Any, List, Optional
import logging
class AssertUtils:
@staticmethod
def assert_status_code(response, expected_status_code: int) -> None:
"""断言响应状态码"""
try:
assert response.status_code == expected_status_code,
f"状态码不匹配: 期望{expected_status_code}, 实际{response.status_code}"
except AssertionError as e:
logging.error(str(e))
raise
@staticmethod
def assert_json_contains_keys(json_data: Dict[str, Any], expected_keys: List[str]) -> None:
"""断言JSON包含指定键"""
missing_keys = [key for key in expected_keys if key not in json_data]
try:
assert not missing_keys,
f"JSON缺少键: {', '.join(missing_keys)}"
except AssertionError as e:
logging.error(str(e))
raise
@staticmethod
def assert_json_value_equal(json_data: Dict[str, Any], key: str, expected_value: Any) -> None:
"""断言JSON中指定键的值等于预期值"""
try:
assert key in json_data,
f"JSON中不存在键: {key}"
assert json_data[key] == expected_value,
f"键{key}的值不匹配: 期望{expected_value}, 实际{json_data[key]}"
except AssertionError as e:
logging.error(str(e))
raise
@staticmethod
def assert_json_value_in_range(json_data: Dict[str, Any], key: str, min_value: Any, max_value: Any) -> None:
"""断言JSON中指定键的值在范围内"""
try:
assert key in json_data,
f"JSON中不存在键: {key}"
value = json_data[key]
assert min_value <= value <= max_value,
f"键{key}的值{value}不在范围内[{min_value}, {max_value}]"
except AssertionError as e:
logging.error(str(e))
raise
6.5 异常处理
6.5.1 自定义异常
# utils/exceptions.py
class APIException(Exception):
"""API异常基类"""
pass
class RequestException(APIException):
"""请求异常"""
def __init__(self, url: str, method: str, error: str):
self.url = url
self.method = method
self.error = error
super().__init__(f"{method}请求{url}失败: {error}")
class ResponseException(APIException):
"""响应异常"""
def __init__(self, url: str, method: str, status_code: int, response_text: str):
self.url = url
self.method = method
self.status_code = status_code
self.response_text = response_text
super().__init__(f"{method}请求{url}返回非预期状态码{status_code}: {response_text}")
class ValidationException(APIException):
"""验证异常"""
def __init__(self, param_name: str, error: str):
self.param_name = param_name
self.error = error
super().__init__(f"参数{param_name}验证失败: {error}")
6.5.2 异常捕获与处理
# api/base_api.py (扩展异常处理)
class BaseAPI:
# ... 已有代码 ...
def _request(self, method: str, endpoint: str, **kwargs) -> requests.Response:
url = f"{self.base_url}{endpoint}"
self.logger.info(f"发送{method}请求: {url}")
try:
response = self.session.request(
method=method,
url=url,
timeout=self.timeout,
**kwargs
)
self.logger.info(f"请求响应状态码: {response.status_code}")
# 检查状态码
if response.status_code >= 400:
raise ResponseException(url, method, response.status_code, response.text)
return response
except requests.exceptions.ConnectionError as e:
self.logger.error(f"连接异常: {str(e)}")
raise RequestException(url, method, f"连接异常: {str(e)}")
except requests.exceptions.Timeout as e:
self.logger.error(f"请求超时: {str(e)}")
raise RequestException(url, method, f"请求超时: {str(e)}")
except requests.exceptions.RequestException as e:
self.logger.error(f"请求异常: {str(e)}")
raise RequestException(url, method, f"请求异常: {str(e)}")
7. 测试用例编写与执行
❝「提示」：本章综合运用前面章节的知识，包括第4章的数据驱动、第5章的工具类、第6章的接口封装，按照基础到进阶的顺序编写测试用例。
❞
7.1 基础测试用例编写
7.1.1 测试用例结构
# testcases/test_web_login.py
import pytest
from api.web_api import WebAPI
from utils.assert_utils import AssertUtils
from utils.yaml_utils import load_yaml_data
import os
class TestWebLogin:
def setup_class(self):
# 加载配置
config_path = os.path.join(os.path.dirname(__file__), "../config/env.yaml")
with open(config_path, "r", encoding="utf-8") as f:
import yaml
config = yaml.safe_load(f)
self.config = config["test"]
# 初始化API客户端
self.web_api = WebAPI(self.config["base_url"])
def test_login_success(self):
"""测试登录成功"""
# 准备数据
username = self.config["username"]
password = self.config["password"]
# 执行请求
response = self.web_api.login(username, password)
# 验证响应
AssertUtils.assert_json_contains_keys(response, ["code", "message", "data"])
AssertUtils.assert_json_value_equal(response, "code", 0)
AssertUtils.assert_json_value_equal(response, "message", "登录成功")
AssertUtils.assert_json_contains_keys(response["data"], ["token", "user_info"])
def test_login_failure_invalid_credentials(self):
"""测试登录失败 - 无效凭据"""
# 准备数据
username = "invalid_user"
password = "invalid_password"
# 执行请求
response = self.web_api.login(username, password)
# 验证响应
AssertUtils.assert_json_value_equal(response, "code", 401)
AssertUtils.assert_json_value_equal(response, "message", "用户名或密码错误")
def test_login_failure_empty_fields(self):
"""测试登录失败 - 空字段"""
# 准备数据
username = ""
password = ""
# 执行请求
response = self.web_api.login(username, password)
# 验证响应
AssertUtils.assert_json_value_equal(response, "code", 400)
AssertUtils.assert_json_value_equal(response, "message", "用户名和密码不能为空")
❝「注意」：此处为了展示一个独立的、基础的测试用例结构，在
❞setup_class中直接加载了配置文件。在实际框架设计中，更推荐的做法是使用conftest.py文件创建session级别的 fixture 来统一管理配置的加载（详见 「7.4 节」），这样可以避免代码重复，并提高执行效率。
7.1.2 测试用例设计原则
# testcases/test_web_login.py
class TestWebLoginDesign:
"""测试用例设计原则示例"""
def test_positive_case(self):
"""正向测试用例 - 正常流程"""
# 使用有效的用户名和密码
pass
def test_negative_case_invalid_input(self):
"""负向测试用例 - 无效输入"""
# 使用无效的用户名或密码
pass
def test_boundary_case_empty_fields(self):
"""边界测试用例 - 空字段"""
# 测试空用户名、空密码、都为空
pass
def test_error_case_system_error(self):
"""异常测试用例 - 系统错误"""
# 模拟系统错误情况
pass
7.2 基础参数化测试用例
7.2.1 pytest参数化测试
# testcases/test_order.py
import pytest
from api.web_api import WebAPI
from utils.assert_utils import AssertUtils
from utils.yaml_utils import load_yaml_data
import os
class TestOrder:
def setup_class(self):
# 加载配置和数据
config_path = os.path.join(os.path.dirname(__file__), "../config/env.yaml")
with open(config_path, "r", encoding="utf-8") as f:
import yaml
config = yaml.safe_load(f)
self.config = config["test"]
# 注意：这里使用订单相关的测试数据，实际项目中需要创建对应的YAML文件
data_path = os.path.join(os.path.dirname(__file__), "../data/Web/test_web_login.yaml")
self.data = load_yaml_data(data_path, "test")
# 初始化API客户端并登录
self.web_api = WebAPI(self.config["base_url"])
login_response = self.web_api.login(self.config["username"], self.config["password"])
self.token = login_response["data"]["token"]
@pytest.mark.parametrize("case", [
{"product_id": 1, "quantity": 1, "expected_status": 200},
{"product_id": 2, "quantity": 5, "expected_status": 200},
{"product_id": 999, "quantity": 1, "expected_status": 404},
{"product_id": 1, "quantity": 0, "expected_status": 400},
{"product_id": 1, "quantity": -1, "expected_status": 400},
])
def test_create_order_parametrize(self, case):
"""使用pytest参数化测试创建订单"""
# 执行请求
response = self.web_api.create_order(
token=self.token,
product_id=case["product_id"],
quantity=case["quantity"]
)
# 验证响应
AssertUtils.assert_json_value_equal(response, "code", case["expected_status"])
@pytest.mark.parametrize("case", self.data["create_order_success"])
def test_create_order_success(self, case):
"""测试创建订单成功"""
# 执行请求
response = self.web_api.create_order(
token=self.token,
product_id=case["product_id"],
quantity=case["quantity"]
)
# 验证响应
AssertUtils.assert_json_value_equal(response, "code", 0)
AssertUtils.assert_json_value_equal(response, "message", case["expected_message"])
AssertUtils.assert_json_contains_keys(response["data"], ["order_id", "total_price"])
AssertUtils.assert_json_value_in_range(
response["data"], "total_price",
case["expected_min_price"],
case["expected_max_price"]
)
@pytest.mark.parametrize("case", self.data["create_order_failure"])
def test_create_order_failure(self, case):
"""测试创建订单失败"""
# 执行请求
with pytest.raises(Exception) as excinfo:
self.web_api.create_order(
token=self.token,
product_id=case["product_id"],
quantity=case["quantity"]
)
# 验证异常
assert case["expected_message"] in str(excinfo.value)
7.2.2 YAML数据驱动测试
# testcases/test_yaml_driven.py
import pytest
from api.web_api import WebAPI
from utils.assert_utils import AssertUtils
from utils.yaml_utils import load_yaml_data
import os
class TestYamlDriven:
def setup_class(self):
# 加载配置
config_path = os.path.join(os.path.dirname(__file__), "../config/env.yaml")
with open(config_path, "r", encoding="utf-8") as f:
import yaml
config = yaml.safe_load(f)
self.config = config["test"]
# 加载测试数据
data_path = os.path.join(os.path.dirname(__file__), "../data/Web/test_web_login.yaml")
self.test_data = load_yaml_data(data_path, "test")
# 初始化API客户端
self.web_api = WebAPI(self.config["base_url"])
@pytest.mark.parametrize("case", [
{"username": "valid_user", "password": "valid_pass", "expected": "success"},
{"username": "invalid_user", "password": "valid_pass", "expected": "failure"},
{"username": "valid_user", "password": "invalid_pass", "expected": "failure"},
{"username": "", "password": "", "expected": "failure"},
])
def test_login_scenarios(self, case):
"""使用硬编码参数测试登录场景"""
response = self.web_api.login(case["username"], case["password"])
if case["expected"] == "success":
AssertUtils.assert_json_value_equal(response, "code", 0)
else:
AssertUtils.assert_json_value_not_equal(response, "code", 0)
@pytest.mark.parametrize("case", [
# 从YAML文件加载的数据
])
def test_login_with_yaml_data(self, case):
"""使用YAML数据测试登录"""
response = self.web_api.login(case["username"], case["password"])
AssertUtils.assert_json_value_equal(response, "code", case["expected_code"])
AssertUtils.assert_json_value_equal(response, "message", case["expected_message"])
7.3 动态钩子参数化测试
7.3.1 使用钩子函数动态生成测试数据
# testcases/test_dynamic_hooks.py
import pytest
from api.web_api import WebAPI
from utils.assert_utils import AssertUtils
import os
class TestDynamicHooks:
def setup_class(self):
# 加载配置
config_path = os.path.join(os.path.dirname(__file__), "../config/env.yaml")
with open(config_path, "r", encoding="utf-8") as f:
import yaml
config = yaml.safe_load(f)
self.config = config["test"]
# 初始化API客户端
self.web_api = WebAPI(self.config["base_url"])
@pytest.mark.data_key("login_success")
def test_login_success_dynamic(self, case):
"""使用钩子函数动态生成测试数据 - 登录成功"""
# case 参数会自动从 YAML 文件中加载
username = case["username"]
password = case["password"]
expected_status = case["expected_status"]
expected_message = case["expected_message"]
# 执行登录测试
response = self.web_api.login(username, password)
# 验证响应
AssertUtils.assert_json_value_equal(response, "code", expected_status)
AssertUtils.assert_json_value_equal(response, "message", expected_message)
@pytest.mark.data_key("login_failure")
def test_login_failure_dynamic(self, case):
"""使用钩子函数动态生成测试数据 - 登录失败"""
# case 参数会自动从 YAML 文件中加载
username = case["username"]
password = case["password"]
expected_status = case["expected_status"]
expected_message = case["expected_message"]
# 执行登录测试
response = self.web_api.login(username, password)
# 验证响应
AssertUtils.assert_json_value_equal(response, "code", expected_status)
AssertUtils.assert_json_value_equal(response, "message", expected_message)
@pytest.mark.data_key("order_creation")
def test_order_creation_dynamic(self, case, auth_token):
"""使用钩子函数动态生成测试数据 - 订单创建"""
# case 参数会自动从 YAML 文件中加载
product_id = case["product_id"]
quantity = case["quantity"]
expected_status = case["expected_status"]
expected_message = case["expected_message"]
# 执行订单创建测试
response = self.web_api.create_order(
token=auth_token,
product_id=product_id,
quantity=quantity
)
# 验证响应
AssertUtils.assert_json_value_equal(response, "code", expected_status)
AssertUtils.assert_json_value_equal(response, "message", expected_message)
7.3.2 复杂场景的动态参数化
# testcases/test_complex_scenarios.py
import pytest
from api.web_api import WebAPI
from utils.assert_utils import AssertUtils
class TestComplexScenarios:
"""复杂场景的动态参数化测试"""
@pytest.mark.data_key("user_registration")
def test_user_registration_flow(self, case):
"""用户注册流程测试"""
# 测试用户注册的完整流程
# 包括：注册 → 验证邮箱 → 登录 → 完善信息
pass
@pytest.mark.data_key("order_workflow")
def test_order_workflow(self, case, auth_token):
"""订单工作流测试"""
# 测试订单的完整流程
# 包括：浏览商品 → 加入购物车 → 下单 → 支付 → 确认收货
pass
@pytest.mark.data_key("payment_scenarios")
def test_payment_scenarios(self, case, auth_token):
"""支付场景测试"""
# 测试不同的支付方式
# 包括：支付宝、微信、银行卡、余额支付等
pass
7.4 测试前置和后置操作
# conftest.py
import pytest
from api.web_api import WebAPI
import os
import logging
@pytest.fixture(scope="session")
def config():
"""加载配置"""
config_path = os.path.join(os.path.dirname(__file__), "config/env.yaml")
with open(config_path, "r", encoding="utf-8") as f:
import yaml
config = yaml.safe_load(f)
return config["test"]
@pytest.fixture(scope="session")
def web_api(config):
"""初始化Web API客户端"""
return WebAPI(config["base_url"])
@pytest.fixture(scope="class")
def auth_token(web_api, config):
"""获取认证token"""
login_response = web_api.login(config["username"], config["password"])
return login_response["data"]["token"]
@pytest.fixture
def cleanup_order(web_api, auth_token):
"""清理创建的订单"""
order_ids = []
yield order_ids
# 测试后清理
for order_id in order_ids:
try:
web_api.cancel_order(token=auth_token, order_id=order_id)
logging.info(f"已取消订单: {order_id}")
except Exception as e:
logging.warning(f"取消订单{order_id}失败: {str(e)}")
7.5 测试执行与结果分析
7.5.1 执行测试
# 执行所有测试
pytest
# 执行指定目录的测试
pytest testcases/web/
# 执行指定文件的测试
pytest testcases/test_web_login.py
# 执行指定函数的测试
pytest testcases/test_web_login.py::TestWebLogin::test_login_success
# 执行带标记的测试
pytest -m web
# 生成Allure报告
pytest --alluredir=reports/allure_data
allure generate reports/allure_data -o reports/allure_report
allure open reports/allure_report
7.6 测试报告定制
7.6.1 Allure报告定制
# allure-config.yml
categories:
- name: 功能测试
matchedStatuses: [passed, failed, broken, skipped]
- name: 冒烟测试
matchedStatuses: [passed, failed, broken]
matchedTags: [smoke]
- name: 性能测试
matchedStatuses: [passed, failed, broken]
matchedTags: [performance]
labels:
- name: severity
pattern: ^( blocker | critical | normal | minor | trivial )$
value: normal
- name: story
pattern: ^( .* )$
value: $1
7.6.2 报告中添加环境信息
# conftest.py
def pytest_configure(config):
"""配置Allure报告"""
# 添加环境信息
allure.dynamic.description("xx电商平台接口自动化测试")
allure.dynamic.severity(allure.severity_level.NORMAL)
# 添加环境变量
allure.dynamic.label("environment", config.getoption("env"))
allure.dynamic.label("platform", "web")
def pytest_runtest_setup(item):
"""测试执行前设置"""
# 为测试用例添加描述
if hasattr(item, 'funcargs') and 'case' in item.funcargs:
case = item.funcargs['case']
if 'description' in case:
allure.dynamic.description(case['description'])
8. 邮件报告发送功能
8.1 邮件发送设计
8.1.1 邮件发送类
# utils/email_utils.py
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.mime.application import MIMEApplication
from email.header import Header
import os
import logging
from datetime import datetime
class EmailSender:
def __init__(self, smtp_server: str, smtp_port: int, username: str, password: str, use_ssl: bool = True):
self.smtp_server = smtp_server
self.smtp_port = smtp_port
self.username = username
self.password = password
self.use_ssl = use_ssl
self.logger = logging.getLogger(__name__)
def connect(self) -> smtplib.SMTP:
"""连接到SMTP服务器"""
try:
if self.use_ssl:
server = smtplib.SMTP_SSL(self.smtp_server, self.smtp_port)
else:
server = smtplib.SMTP(self.smtp_server, self.smtp_port)
server.starttls()
server.login(self.username, self.password)
self.logger.info(f"成功连接到SMTP服务器: {self.smtp_server}:{self.smtp_port}")
return server
except Exception as e:
self.logger.error(f"连接SMTP服务器失败: {str(e)}")
raise
def send_email(self,
subject: str,
content: str,
recipients: list,
sender: str,
cc: list = None,
bcc: list = None,
attachments: list = None) -> bool:
"""发送邮件"""
if cc is None:
cc = []
if bcc is None:
bcc = []
if attachments is None:
attachments = []
try:
# 创建邮件对象
msg = MIMEMultipart()
msg["From"] = Header(sender, "utf-8")
msg["To"] = Header(", ".join(recipients), "utf-8")
msg["Subject"] = Header(subject, "utf-8")
if cc:
msg["Cc"] = Header(", ".join(cc), "utf-8")
# 添加正文
msg.attach(MIMEText(content, "html", "utf-8"))
# 添加附件
for file_path in attachments:
if os.path.exists(file_path):
with open(file_path, "rb") as f:
part = MIMEApplication(f.read())
part.add_header("Content-Disposition", "attachment", filename=Header(os.path.basename(file_path), "utf-8").encode())
msg.attach(part)
else:
self.logger.warning(f"附件文件不存在: {file_path}")
# 连接服务器并发送邮件
server = self.connect()
all_recipients = recipients + cc + bcc
server.sendmail(sender, all_recipients, msg.as_string())
server.quit()
self.logger.info(f"邮件发送成功，收件人: {', '.join(recipients)}")
return True
except Exception as e:
self.logger.error(f"邮件发送失败: {str(e)}")
raise
❝「提示」：本节提供了一个基础的邮件发送实现。在真实的持续集成环境中，由于网络波动、邮箱服务商的安全策略等原因，邮件发送可能会失败。针对这些常见问题，在 「11.2 节」 提供了包括主备邮箱自动切换和指数退避重试在内的生产级解决方案，建议你在实际应用中参考和采纳。
❞
8.1.2 邮件配置加载
# config/email_config.py
class EmailConfig:
# SMTP服务器配置
SMTP_SERVER = "smtp.exmail.qq.com"
SMTP_PORT = 465
SMTP_USERNAME = "test@example.com"
SMTP_PASSWORD = "password"
USE_SSL = True
# 邮件内容配置
SUBJECT = "xx电商平台接口自动化测试报告"
SENDER = "qa@example.com"
RECIPIENTS = ["developer@example.com", "tester@example.com"]
CC = []
BCC = []
❝「警告」：此示例中直接在代码中硬编码了邮箱密码，这在生产环境中是不安全的。建议使用环境变量或Jenkins Credentials来管理敏感信息。
❞
8.2 测试报告邮件模板
8.2.1 HTML邮件模板
# utils/email_templates.py
class EmailTemplate:
@staticmethod
def generate_report_template(report_title: str,
report_url: str,
pass_rate: float,
total_cases: int,
passed_cases: int,
failed_cases: int,
broken_cases: int,
skipped_cases: int,
start_time: str,
end_time: str,
duration: str) -> str:
"""生成测试报告邮件模板"""
# 确定通过率颜色
if pass_rate == 100:
rate_color = "#28a745"
elif pass_rate >= 90:
rate_color = "#17a2b8"
elif pass_rate >= 80:
rate_color = "#ffc107"
else:
rate_color = "#dc3545"
# 生成HTML内容
html_content = f"""
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>{report_title}</title>
<style>
body {{ font-family: 'Microsoft YaHei', Arial, sans-serif; margin: 0; padding: 0; background-color: #f8f9fa; }}
.container {{ max-width: 800px; margin: 0 auto; padding: 20px; background-color: #ffffff; box-shadow: 0 0 10px rgba(0, 0, 0, 0.1); }}
.header {{ background-color: #007bff; color: #ffffff; padding: 15px; text-align: center; border-radius: 5px 5px 0 0; }}
.content {{ padding: 20px; }}
.stats {{ display: flex; flex-wrap: wrap; justify-content: space-between; margin-bottom: 20px; }}
.stat-item {{ flex: 1; min-width: 120px; margin: 10px; padding: 15px; background-color: #f8f9fa; border-radius: 5px; text-align: center; }}
.stat-value {{ font-size: 24px; font-weight: bold; margin: 5px 0; }}
.pass-rate {{ color: {rate_color}; }}
.footer {{ text-align: center; padding: 15px; background-color: #f8f9fa; border-radius: 0 0 5px 5px; font-size: 14px; color: #6c757d; }}
.button {{ display: inline-block; background-color: #007bff; color: white; padding: 10px 20px; text-decoration: none; border-radius: 5px; margin-top: 10px; }}
</style>
</head>
<body>
<div class="container">
<div class="header">
<h1>{report_title}</h1>
</div>
<div class="content">
<div class="stats">
<div class="stat-item">
<div>总用例数</div>
<div class="stat-value">{total_cases}</div>
</div>
<div class="stat-item">
<div>通过用例</div>
<div class="stat-value" style="color: #28a745;">{passed_cases}</div>
</div>
<div class="stat-item">
<div>失败用例</div>
<div class="stat-value" style="color: #dc3545;">{failed_cases}</div>
</div>
<div class="stat-item">
<div>通过率</div>
<div class="stat-value pass-rate">{pass_rate}%</div>
</div>
</div>
<div>
<p><strong>测试开始时间:</strong> {start_time}</p>
<p><strong>测试结束时间:</strong> {end_time}</p>
<p><strong>测试持续时间:</strong> {duration}</p>
<p><a href="{report_url}" class="button">查看详细报告</a></p>
</div>
</div>
<div class="footer">
<p>此邮件由电商平台接口自动化测试框架自动发送，请勿回复。</p>
</div>
</div>
</body>
</html>
"""
return html_content
8.3 邮件发送集成
8.3.1 与测试框架集成
# conftest.py
import pytest
from utils.email_utils import EmailSender
from utils.email_templates import EmailTemplate
from config.email_config import EmailConfig
from datetime import datetime
import os
import logging
# 记录测试开始时间
TEST_START_TIME = datetime.now()
@pytest.fixture(scope="session", autouse=True)
def record_test_start_time():
"""记录测试开始时间"""
global TEST_START_TIME
TEST_START_TIME = datetime.now()
logging.info(f"测试开始时间: {TEST_START_TIME.strftime('%Y-%m-%d %H:%M:%S')}")
yield
@pytest.hookimpl(tryfirst=True, hookwrapper=True)
def pytest_runtest_makereport(item, call):
"""收集测试结果"""
outcome = yield
report = outcome.get_result()
# 确保测试结果被记录
if report.when == "call":
# 可以在这里记录测试结果到全局变量
pass
def pytest_terminal_summary(terminalreporter, exitstatus, config):
"""测试结束后发送邮件报告"""
# 记录测试结束时间
test_end_time = datetime.now()
test_duration = test_end_time - TEST_START_TIME
# 格式化时间
start_time_str = TEST_START_TIME.strftime('%Y-%m-%d %H:%M:%S')
end_time_str = test_end_time.strftime('%Y-%m-%d %H:%M:%S')
duration_str = str(test_duration).split('.')[0] # 去掉毫秒部分
# 获取测试统计信息
total_cases = terminalreporter._numcollected
passed_cases = len([report for report in terminalreporter.getreports() if report.passed])
failed_cases = len([report for report in terminalreporter.getreports() if report.failed])
broken_cases = len([report for report in terminalreporter.getreports() if report.broken])
skipped_cases = len([report for report in terminalreporter.getreports() if report.skipped])
# 计算通过率
if total_cases > 0:
pass_rate = round((passed_cases / total_cases) * 100, 2)
else:
pass_rate = 0
# 生成邮件内容
email_template = EmailTemplate()
email_content = email_template.generate_report_template(
report_title="xx电商平台接口自动化测试报告",
pass_rate=pass_rate,
total_cases=total_cases,
passed_cases=passed_cases,
failed_cases=failed_cases,
broken_cases=broken_cases,
skipped_cases=skipped_cases,
start_time=start_time_str,
end_time=end_time_str,
duration=duration_str
)
# 发送邮件
try:
email_sender = EmailSender(
smtp_server=EmailConfig.SMTP_SERVER,
smtp_port=EmailConfig.SMTP_PORT,
username=EmailConfig.SMTP_USERNAME,
password=EmailConfig.SMTP_PASSWORD,
use_ssl=EmailConfig.USE_SSL
)
email_sender.send_email(
subject=EmailConfig.SUBJECT,
content=email_content,
recipients=EmailConfig.RECIPIENTS,
sender=EmailConfig.SENDER,
cc=EmailConfig.CC,
bcc=EmailConfig.BCC,
attachments=["reports/allure_report/index.html"] # 附件可选
)
except Exception as e:
logging.error(f"发送邮件报告失败: {str(e)}")
8.3.2 命令行参数控制
from utils.email_utils import EmailSender
from utils.email_templates import EmailTemplate
def parse_args():
"""解析命令行参数"""
parser = argparse.ArgumentParser(description="xx电商平台接口自动化测试框架")
parser.add_argument("--env", type=str, default="test", help="环境: test/prod")
parser.add_argument("--send-email", action="store_true", help="发送邮件报告")
parser.add_argument("--report-dir", type=str, default="reports/allure_report", help="报告目录")
return parser.parse_args()
if __name__ == "__main__":
# 解析命令行参数
args = parse_args()
# 运行测试
pytest.main([
"testcases/",
f"--alluredir=reports/allure_data",
f"-m not slow"
])
# 生成报告
os.system(f"allure generate reports/allure_data -o {args.report_dir} --clean")
# 发送邮件报告
if args.send_email:
try:
# 准备邮件内容
# ... (类似conftest.py中的代码) ...
# 发送邮件
email_sender = EmailSender(
smtp_server=EmailConfig.SMTP_SERVER,
smtp_port=EmailConfig.SMTP_PORT,
username=EmailConfig.SMTP_USERNAME,
password=EmailConfig.SMTP_PASSWORD,
use_ssl=EmailConfig.USE_SSL
)
# 调用发送邮件方法
# ...
except Exception as e:
print(f"发送邮件失败: {str(e)}")
9. Jenkins持续集成
9.1 Jenkins环境准备
9.1.1 Jenkins安装
-
访问Jenkins官网下载最新版本
-
按照官方文档安装Jenkins
-
启动Jenkins服务
-
访问Jenkins web界面（默认端口8080）
-
完成初始化设置
9.1.2 必要插件安装
-
「Allure Jenkins Plugin」：用于生成Allure测试报告
-
「Git Plugin」：用于从Git仓库拉取代码
-
「Pipeline Plugin」：用于创建Pipeline任务
-
「Email Extension Plugin」：增强邮件通知功能
-
「Python Plugin」：用于Python环境配置
9.2 Jenkins任务配置
9.2.1 自由风格任务配置
❝「提示」：Jenkins提供了多种任务类型。首先介绍操作简单、界面友好的"自由风格任务"，它适合快速搭建简单的自动化任务。然而，对于更复杂的构建流程和"持续集成/持续部署"（CI/CD）的最佳实践，更推荐使用 「9.2.2 节」 中介绍的"Pipeline"（流水线）任务，因为它能将构建流程代码化（Jenkinsfile），更易于版本控制、复用和维护。
❞
-
「源码管理」：
-
选择Git
-
填写仓库URL
-
配置认证信息
-
选择分支
-
-
「构建环境」：
-
选择Python版本
-
设置环境变量
-
-
「构建」：
-
执行shell命令：
# 安装依赖 pip install -r requirements.txt # 运行测试 pytest --alluredir=reports/allure_data -
-
「构建后操作」：
-
生成Allure报告
-
发送邮件通知
-
9.2.2 Pipeline任务配置
// Jenkinsfile
pipeline {
agent any
environment {
// 环境变量配置
PYTHON_HOME = tool 'Python 3.11'
PATH = "${PYTHON_HOME}/bin:${env.PATH}"
}
stages {
stage('Checkout') {
steps {
// 拉取代码
git url: 'https://gitee.com/username/InterfaceAutomation.git', branch: 'main'
}
}
stage('Install Dependencies') {
steps {
// 安装依赖
sh 'pip install -r requirements.txt'
}
}
stage('Run Tests') {
steps {
// 运行测试
sh 'pytest --alluredir=reports/allure_data'
}
}
stage('Generate Report') {
steps {
// 生成Allure报告
allure commandline: 'allure-2.34.0', results: [[path: 'reports/allure_data']]
}
}
}
post {
always {
// 发送邮件通知
emailext (
subject: 'xx电商平台接口自动化测试报告 - ${BUILD_STATUS}',
body: '''<p>测试结果:</p>
<p>构建状态: ${BUILD_STATUS}</p>
<p>构建编号: ${BUILD_NUMBER}</p>
<p>测试报告: <a href='${BUILD_URL}allure'>查看报告</a></p>''',
recipientProviders: [[$class: 'DevelopersRecipientProvider'], [$class: 'RequesterRecipientProvider']]
)
}
}
}
9.3 定时任务配置
9.3.1 自由风格任务定时配置
-
在任务配置页面，找到"构建触发器"部分
-
选择"定期构建"
- 填写Cron表达式，例如：
-
H 8 * * *：每天8点执行 -
H 8,18 * * *：每天8点和18点执行 -
H */4 * * *：每4小时执行一次 -
H 8 * * 1-5：每周一至周五8点执行
-
9.3.2 Pipeline任务定时配置
在Jenkinsfile中添加triggers块：
pipeline {
agent any
triggers {
cron('H 8 * * *') // 每天8点执行
}
// 其他配置...
}
9.4 条件执行策略
// Jenkinsfile (条件执行)
pipeline {
agent any
stages {
stage('Checkout') {
steps {
git url: 'https://gitee.com/username/InterfaceAutomation.git', branch: 'main'
}
}
stage('Build and Test') {
steps {
script {
// 根据分支执行不同的测试
if (env.BRANCH_NAME == 'main') {
sh 'pytest --alluredir=reports/allure_data -m smoke'
} else {
sh 'pytest --alluredir=reports/allure_data'
}
}
}
}
}
post {
// 条件发送邮件
success {
emailext subject: '测试成功通知', body: '测试已成功完成', recipientProviders: [[$class: 'DevelopersRecipientProvider']]
}
failure {
emailext subject: '测试失败通知', body: '测试失败，请查看报告', recipientProviders: [[$class: 'DevelopersRecipientProvider'], [$class: 'RequesterRecipientProvider']]
}
}
}
9.5 邮件配置
9.5.1 全局邮件配置
-
在Jenkins系统管理 -> 系统配置 -> "邮件通知"，配置SMTP服务器信息
-
测试邮件配置
9.5.2 任务级邮件配置
// Jenkinsfile (邮件配置)
post {
always {
emailext (
subject: 'xx电商平台接口自动化测试报告 - ${BUILD_STATUS}',
body: '''<html>
<body>
<h2>测试结果摘要</h2>
<p>构建状态: ${BUILD_STATUS}</p>
<p>构建编号: ${BUILD_NUMBER}</p>
<p>构建URL: <a href='${BUILD_URL}'>${BUILD_URL}</a></p>
<p>测试报告: <a href='${BUILD_URL}allure'>查看Allure报告</a></p>
<h3>测试统计</h3>
<p>总用例数: ${ALLURE_TESTS_TOTAL}</p>
<p>通过用例数: ${ALLURE_TESTS_PASSED}</p>
<p>失败用例数: ${ALLURE_TESTS_FAILED}</p>
<p>通过率: ${ALLURE_TESTS_PASSED_RATE}%</p>
</body>
</html>''',
mimeType: 'text/html',
recipientProviders: [[$class: 'DevelopersRecipientProvider'], [$class: 'RequesterRecipientProvider']],
attachLog: true
)
}
}
10. Docker容器化部署
❝「背景」：在第9章中，学习了如何在Jenkins主机上直接执行测试。这种方式虽然可行，但严重依赖主机的环境（如Python版本、库依赖等），可能导致"在我机器上能跑，到服务器上就失败"的环境不一致问题。为了彻底解决这个问题，本章将引入Docker容器化技术。通过将测试框架及其所有依赖打包成一个独立的、可移植的镜像，可以确保在任何地方都拥有一致的运行环境，这是实现稳定、可靠的CI/CD流程的关键一步。
❞
10.2 测试环境容器化
10.2.1 Dockerfile编写
# Dockerfile
# 使用Python官方镜像作为基础镜像
FROM python:3.11-slim
# 设置工作目录
WORKDIR /app
# 复制依赖文件
COPY requirements.txt .
# 安装依赖
RUN pip install --no-cache-dir -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
# 复制项目代码
COPY . .
# 设置环境变量
ENV ENV=test
# 运行测试
CMD ["pytest", "--alluredir=reports/allure_data"]
10.2.2 docker-compose配置
# docker-compose.yml
version: '3'
services:
test:
build: .
volumes:
- ./reports:/app/reports
environment:
- ENV=test
depends_on:
- mysql
- redis
mysql:
image: mysql:8.0
environment:
- MYSQL_ROOT_PASSWORD=root
- MYSQL_DATABASE=test_db
ports:
- "3306:3306"
volumes:
- mysql_data:/var/lib/mysql
redis:
image: redis:6.2
ports:
- "6379:6379"
volumes:
- redis_data:/data
volumes:
mysql_data:
redis_data:
❝「警告」：此示例中使用了简单的密码配置，仅适用于开发测试环境。在生产环境中，请使用强密码并通过环境变量或Docker secrets来管理敏感信息。
❞
10.3 Jenkins容器化部署
10.3.1 Jenkins Dockerfile
# Jenkins Dockerfile
FROM jenkins/jenkins:lts-jdk11
# 切换到root用户安装依赖
USER root
# 安装Docker
RUN apt-get update && apt-get install -y docker.io
# 安装Docker Compose
RUN curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
RUN chmod +x /usr/local/bin/docker-compose
# 安装Allure
RUN wget https://github.com/allure-framework/allure2/releases/download/2.34.0/allure-2.34.0.tgz
RUN tar -zxvf allure-2.34.0.tgz -C /opt/
RUN ln -s /opt/allure-2.34.0/bin/allure /usr/local/bin/allure
# 切换回jenkins用户
USER jenkins
# 安装必要插件
RUN jenkins-plugin-cli --plugins allure-jenkins-plugin git pipeline email-ext python
10.3.2 Jenkins docker-compose配置
# jenkins-docker-compose.yml
version: '3'
services:
jenkins:
build: .
ports:
- "8080:8080"
- "50000:50000"
volumes:
- jenkins_home:/var/jenkins_home
- /var/run/docker.sock:/var/run/docker.sock
environment:
- JAVA_OPTS=-Duser.timezone=Asia/Shanghai
volumes:
jenkins_home:
10.4 Jenkins Pipeline配置
// Jenkinsfile (Docker版本)
pipeline {
agent any
environment {
DOCKER_COMPOSE = "docker-compose.yml"
}
stages {
stage('Checkout') {
steps {
git url: 'https://gitee.com/username/InterfaceAutomation.git', branch: 'main'
}
}
stage('Build Docker Image') {
steps {
sh 'docker-compose -f ${DOCKER_COMPOSE} build'
}
}
stage('Run Tests in Container') {
steps {
sh 'docker-compose -f ${DOCKER_COMPOSE} up --abort-on-container-exit'
}
}
stage('Generate Report') {
steps {
sh 'docker-compose -f ${DOCKER_COMPOSE} run --rm test allure generate reports/allure_data -o reports/allure_report'
}
}
}
post {
always {
// 发送邮件报告
emailext (
subject: '接口自动化测试报告 - ${BUILD_STATUS}',
body: '''<p>测试结果:</p>
<p>构建状态: ${BUILD_STATUS}</p>
<p>构建编号: ${BUILD_NUMBER}</p>
<p>测试报告: <a href='${BUILD_URL}allure'>查看报告</a></p>''',
recipientProviders: [[$class: 'DevelopersRecipientProvider'], [$class: 'RequesterRecipientProvider']]
)
// 清理容器
sh 'docker-compose -f ${DOCKER_COMPOSE} down'
}
}
}
10.5 多环境部署配置
# docker-compose.test.yml
version: '3'
services:
test:
build: .
volumes:
- ./reports:/app/reports
environment:
- ENV=test
depends_on:
- mysql
- redis
# docker-compose.prod.yml
version: '3'
services:
test:
build: .
volumes:
- ./reports:/app/reports
environment:
- ENV=prod
depends_on:
- mysql
- redis
# 运行测试环境
docker-compose -f docker-compose.test.yml up
# 运行生产环境
docker-compose -f docker-compose.prod.yml up
10.6 容器编排管理
10.6.1 使用Docker Swarm
# 初始化Swarm
docker swarm init
# 部署服务
docker stack deploy -c docker-compose.yml test_stack
# 查看服务状态
docker service ls
# 扩展服务
docker service scale test_stack_test=3
10.6.2 使用Kubernetes
# kubernetes/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: interface-automation
spec:
replicas: 3
selector:
matchLabels:
app: interface-automation
template:
metadata:
labels:
app: interface-automation
spec:
containers:
- name: interface-automation
image: interface-automation:latest
env:
- name: ENV
value: "test"
volumeMounts:
- name: reports
mountPath: /app/reports
volumes:
- name: reports
persistentVolumeClaim:
claimName: reports-pvc
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: reports-pvc
spec:
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 1Gi
10.7 监控与日志
10.7.1 Docker日志查看
# 查看容器日志
docker logs [container_id]
# 实时查看日志
docker logs -f [container_id]
# 查看最后100行日志
docker logs --tail 100 [container_id]
10.7.2 集成ELK日志收集
# docker-compose.yml (添加ELK)
version: '3'
services:
# ... 已有服务 ...
elasticsearch:
image: elasticsearch:7.14.0
environment:
- discovery.type=single-node
ports:
- "9200:9200"
volumes:
- es_data:/usr/share/elasticsearch/data
logstash:
image: logstash:7.14.0
volumes:
- ./logstash/pipeline:/usr/share/logstash/pipeline
depends_on:
- elasticsearch
kibana:
image: kibana:7.14.0
ports:
- "5601:5601"
depends_on:
- elasticsearch
volumes:
# ... 已有卷 ...
es_data:
11. 常见问题与最佳实践汇总
❝「说明」：本章汇总了在实际项目中使用前面章节介绍的框架时可能遇到的常见问题及其解决方案。这些问题和解决方案都是基于真实项目经验总结而来，是对前面章节内容的补充和完善。建议在实践过程中遇到问题时，优先查阅本章相关内容。
❞
11.1 pytest框架常见问题
11.1.1 钩子函数执行顺序混乱
「症状」：多个钩子函数执行顺序不符合预期，导致配置冲突
「解决方案」：
# 使用hookwrapper装饰器控制执行顺序
@pytest.hookimpl(tryfirst=True, hookwrapper=True)
def pytest_runtest_makereport(item, call):
"""确保在其他钩子之前执行"""
outcome = yield
report = outcome.get_result()
# 处理逻辑
return report
@pytest.hookimpl(trylast=True)
def pytest_configure(config):
"""确保在其他钩子之后执行"""
# 配置逻辑
pass
# 使用hookimpl的tryfirst、trylast参数控制优先级
@pytest.hookimpl(tryfirst=True)
def pytest_addoption(parser):
"""优先添加命令行参数"""
parser.addoption("--env", action="store", default="test")
11.1.2 pytest_generate_tests钩子函数性能问题
「症状」：大量测试用例时，动态参数化导致测试收集时间过长
「解决方案」：
# 使用缓存机制优化性能
_test_data_cache = {}
def pytest_generate_tests(metafunc):
"""优化的动态参数化，使用缓存提高性能"""
if "case" in metafunc.fixturenames:
data_key_markers = list(
metafunc.definition.iter_markers(name="data_key"))
if data_key_markers:
data_key = data_key_markers[0].args[0]
module_file_path = metafunc.module.__file__
# 使用缓存键
cache_key = f"{module_file_path}_{data_key}"
# 检查缓存
if cache_key not in _test_data_cache:
try:
test_data = load_test_data(metafunc, data_key)
_test_data_cache[cache_key] = test_data
except Exception as e:
pytest.fail(f"加载测试数据失败: {e}")
# 使用缓存的数据
metafunc.parametrize(
"case",
_test_data_cache[cache_key],
ids=lambda x: x.get('case_id', 'unknown')
)
11.1.3 钩子函数中的异常处理不当
「症状」：钩子函数中的异常导致整个测试会话失败
「解决方案」：
def pytest_generate_tests(metafunc):
"""动态生成测试参数，包含完善的错误处理"""
try:
if "case" in metafunc.fixturenames:
data_key_markers = list(
metafunc.definition.iter_markers(name="data_key"))
if not data_key_markers:
pytest.fail(
f"测试方法 '{metafunc.function.__name__}' 需要 'case' 参数，"
f"但缺少 '@pytest.mark.data_key(\"your_key\")' 标记"
)
data_key = data_key_markers[0].args[0]
# 加载测试数据
try:
test_data = load_test_data(metafunc, data_key)
except FileNotFoundError as e:
pytest.fail(f"测试数据文件未找到: {e}")
except yaml.YAMLError as e:
pytest.fail(f"测试数据文件格式错误: {e}")
except KeyError as e:
pytest.fail(f"测试数据键 '{data_key}' 不存在: {e}")
# 参数化测试
metafunc.parametrize("case", test_data, ids=lambda x: x.get('case_id', 'unknown'))
except Exception as e:
pytest.fail(f"动态参数化失败: {e}")
11.1.4 钩子函数调试困难
「症状」：钩子函数执行时难以调试，无法确定执行流程和变量状态
「解决方案」：
import logging
# 设置详细的日志记录
logger = logging.getLogger(__name__)
def pytest_generate_tests(metafunc):
"""添加详细日志的钩子函数"""
logger.info(f"开始处理测试方法: {metafunc.function.__name__}")
logger.info(f"需要的fixture参数: {metafunc.fixturenames}")
if "case" in metafunc.fixturenames:
data_key_markers = list(
metafunc.definition.iter_markers(name="data_key"))
logger.info(f"找到的data_key标记: {data_key_markers}")
if data_key_markers:
data_key = data_key_markers[0].args[0]
logger.info(f"使用的数据键: {data_key}")
# 记录文件路径信息
module_file_path = metafunc.module.__file__
logger.info(f"测试模块路径: {module_file_path}")
try:
# 加载测试数据
test_data = load_test_data(metafunc, data_key)
logger.info(f"成功加载测试数据，共 {len(test_data)} 条")
# 参数化测试
metafunc.parametrize("case", test_data, ids=lambda x: x.get('case_id', 'unknown'))
logger.info("参数化完成")
except Exception as e:
logger.error(f"处理测试数据时出错: {e}")
pytest.fail(f"动态参数化失败: {e}")
# 使用pytest的--tb=short选项减少回溯信息
# 使用pytest -s显示print输出
# 使用pytest --log-cli-level=DEBUG显示详细日志
11.1.5 测试用例执行顺序问题
「症状」：测试用例依赖执行顺序
「解决方案」：
# 确保测试用例独立性
# 不依赖执行顺序
# 使用fixtures进行测试前置准备
# 如确需控制顺序，使用依赖标记
@pytest.mark.dependency()
def test_login():
pass
@pytest.mark.dependency(depends=["test_login"])
def test_create_order():
pass
11.1.6 测试数据污染
「症状」：测试用例之间相互影响
「解决方案」：
# 使用fixtures进行测试后清理
@pytest.fixture
def cleanup_data():
# 测试前准备
yield
# 测试后清理
pass
# 使用独立的测试数据
# 每次测试使用新的测试数据
11.2 邮件模块问题汇总
❝「说明」：本节内容是对第8章基础邮件发送功能的完善和补充。如果你在使用第8章的基础邮件发送功能时遇到问题，本节提供了生产级的解决方案，包括主备邮箱切换、重试机制、错误处理等。
❞
11.2.1 SMTP 535认证失败
「症状」：发送邮件时出现 535 authentication failed, system busy 错误
「原因分析」：
-
邮箱服务商的安全策略限制
-
发送频率过高触发防护机制
-
网络连接不稳定
-
邮箱配置问题
「解决方案」：
「11.2.1.1 实现自动邮箱切换机制」：
def send_test_report(test_results, report_dir, recipients=None, cc_recipients=None):
"""发送测试报告邮件，支持自动邮箱切换"""
try:
# 获取邮件配置
email_config = get_email_config_from_env()
# 首先尝试主邮箱发送
success = _send_email_with_config(
email_config['primary'],
email_config['recipients'],
test_results,
report_dir
)
if not success:
# 主邮箱失败，尝试备用邮箱
logger.warning("主邮箱发送失败，尝试使用备用邮箱...")
success = _send_email_with_config(
email_config['backup'],
email_config['recipients'],
test_results,
report_dir,
subject_suffix="(备用邮箱)"
)
return success
except Exception as e:
logger.error(f"邮件发送失败: {str(e)}")
return False
「11.2.1.2 统一配置管理」：
# config/env.yaml
common:
email:
recipients:
- "leader@qq.com"
- "other_email@163.com"
primary:
smtp_server: "smtp.qq.com"
smtp_port: 465
username: "qa@qq.com"
password: "qq_auth_code"
use_ssl: true
name: "QQ邮箱"
backup:
smtp_server: "smtp.163.com"
smtp_port: 465
username: "qa@163.com"
password: "163_auth_code"
use_ssl: true
name: "163邮箱"
「11.2.1.3 重试机制优化」：
def _send_email(smtp_config, to_emails, subject, html_content, report_path=None, max_retries=2, retry_delay=30):
"""发送邮件，支持重试机制"""
for attempt in range(max_retries + 1):
try:
# 创建SSL上下文
context = ssl.create_default_context()
context.check_hostname = False
context.verify_mode = ssl.CERT_NONE
# 连接SMTP服务器
with smtplib.SMTP_SSL(smtp_config['smtp_server'], smtp_config['smtp_port'], context=context, timeout=30) as server:
server.login(smtp_config['username'], smtp_config['password'])
# 发送邮件
msg = MIMEMultipart()
msg['From'] = smtp_config['username']
msg['To'] = ', '.join(to_emails)
msg['Subject'] = Header(subject, 'utf-8')
# 添加HTML内容
msg.attach(MIMEText(html_content, 'html', 'utf-8'))
# 添加附件
if report_path and os.path.exists(report_path):
with open(report_path, 'rb') as f:
attachment = MIMEApplication(f.read(), _subtype='html')
attachment.add_header('Content-Disposition', 'attachment', filename='test_report.html')
msg.attach(attachment)
server.send_message(msg)
logger.info(f"邮件发送成功 ({smtp_config['name']})")
return True
except smtplib.SMTPAuthenticationError as e:
if "535" in str(e):
logger.error(f"SMTP认证失败 (535错误): {str(e)}")
if attempt < max_retries:
logger.info(f"等待 {retry_delay} 秒后重试...")
time.sleep(retry_delay)
retry_delay *= 2 # 指数退避
continue
else:
logger.error(f"SMTP认证失败: {str(e)}")
break
except Exception as e:
logger.error(f"邮件发送异常: {str(e)}")
if attempt < max_retries:
logger.info(f"等待 {retry_delay} 秒后重试...")
time.sleep(retry_delay)
retry_delay *= 2
continue
break
return False
11.2.2 测试失败详情解析不准确
「症状」：
-
邮件中显示f-string模板（如
{expected_code}）而不是实际值 -
重试的测试用例被重复计算
-
多个断言失败只显示第一个
-
响应内容被截断显示
「解决方案」：
「11.2.2.1 改进错误消息提取」：
def extract_useful_error_message(message: str, trace: str) -> str:
"""提取有用的错误消息，特别处理断言失败的情况"""
import re
if not message and not trace:
return '无错误消息'
full_text = f"{message}\n{trace}"
# 收集所有的断言失败信息，使用集合去重
assertions = set()
# 1. 提取所有状态码断言失败
status_code_pattern = r'AssertionError:\s*期望状态码\s*(\d+).*?实际为\s*(\d+)'
status_code_matches = re.findall(status_code_pattern, full_text)
for expected, actual in status_code_matches:
if expected.isdigit() and actual.isdigit():
assertions.add(f"状态码断言失败：期望 {expected}，实际 {actual}")
# 2. 提取所有响应内容断言失败
content_assertion_pattern = r'AssertionError:\s*期望响应包含\s*[\'\"]((?!{)[^\'\"]+?)[\'\"].*?实际响应为\s*[\'\"](.*?)[\'\"](?:\s|$)'
content_assertion_matches = re.findall(content_assertion_pattern, full_text, re.DOTALL)
for expected_content, actual_content in content_assertion_matches:
# 跳过包含变量名的匹配
if '{' in expected_content or '{' in actual_content[:10]:
continue
# 智能截断JSON内容
if len(actual_content) > 120:
if actual_content.startswith('{'):
# 在完整的属性处截断
brace_count = 0
cut_pos = 0
for i, char in enumerate(actual_content):
if char == '{':
brace_count += 1
elif char == '}':
brace_count -= 1
if brace_count == 0 and i < 120:
cut_pos = i + 1
break
elif i > 100 and char == ',' and brace_count == 1:
cut_pos = i
break
if cut_pos > 0:
actual_display = actual_content[:cut_pos] + '...'
else:
actual_display = actual_content[:120] + '...'
else:
actual_display = actual_content[:120] + '...'
else:
actual_display = actual_content
if not ('{' in expected_content or '{' in actual_display):
assertions.add(f"响应内容断言失败：期望包含 '{expected_content}'，实际响应 '{actual_display}'")
# 3. 提取所有响应时间断言失败
time_assertion_pattern = r'AssertionError:\s*期望响应时间.*?(\d+)ms.*?实际为\s*([\d.]+)ms'
time_assertion_matches = re.findall(time_assertion_pattern, full_text)
for expected_time, actual_time in time_assertion_matches:
assertions.add(f"响应时间断言失败：期望 ≤{expected_time}ms，实际 {actual_time}ms")
# 组合显示所有断言失败
if assertions:
assertions_list = sorted(list(assertions))
if len(assertions_list) == 1:
return assertions_list[0]
else:
return f"多个断言失败({len(assertions_list)}个)：" + " | ".join(assertions_list)
return '断言失败：请查看详细报告'
「11.2.2.2 测试结果去重处理」：
def parse_test_results(json_dir: str) -> dict:
"""解析测试结果统计，处理重试用例去重"""
try:
import json
results = {
'total': 0,
'passed': 0,
'failed': 0,
'skipped': 0,
'duration': 'N/A',
'environment': 'N/A',
'failed_tests': [],
'failure_categories': {}
}
# 遍历JSON文件统计结果，需要去重处理重试用例
test_results_map = {} # 用于存储每个测试的最终结果
if os.path.exists(json_dir):
# 首先读取所有测试结果
all_test_data = []
for filename in os.listdir(json_dir):
if filename.endswith('-result.json'):
file_path = os.path.join(json_dir, filename)
try:
with open(file_path, 'r', encoding='utf-8') as f:
data = json.load(f)
all_test_data.append(data)
except Exception as e:
logger.warning(f"解析测试结果文件失败: {filename}, 错误: {str(e)}")
continue
# 按测试名称分组，每组内按时间排序，取最后一次执行的结果
duplicate_count = 0
for data in all_test_data:
test_name = data.get('name', '')
if not test_name:
continue
test_key = test_name
stop_time = data.get('stop', 0)
if test_key not in test_results_map:
test_results_map[test_key] = data
else:
duplicate_count += 1
# 比较执行时间，保留最后执行的结果
existing_stop = test_results_map[test_key].get('stop', 0)
if stop_time > existing_stop:
test_results_map[test_key] = data
logger.info(f"📊 去重前JSON文件数量：{len(all_test_data)}")
logger.info(f"📊 发现重复执行（重试）记录：{duplicate_count} 个")
logger.info(f"📊 去重后测试用例数量：{len(test_results_map)}")
# 统计去重后的测试结果
for test_key, data in test_results_map.items():
if 'status' in data:
results['total'] += 1
status = data['status']
if status == 'passed':
results['passed'] += 1
elif status == 'failed':
results['failed'] += 1
# 分析失败原因
failure_info = analyze_failure(data)
results['failed_tests'].append(failure_info)
# 按类别统计失败原因
category = failure_info['category']
if category not in results['failure_categories']:
results['failure_categories'][category] = 0
results['failure_categories'][category] += 1
elif status == 'skipped':
results['skipped'] += 1
return results
except Exception as e:
logger.error(f"解析测试结果失败: {str(e)}")
return {
'total': 0,
'passed': 0,
'failed': 0,
'skipped': 0,
'duration': 'N/A',
'environment': 'N/A',
'failed_tests': [],
'failure_categories': {}
}
11.2.3 环境显示优化
「症状」：邮件中环境显示为英文代码（如 test、prod），不够直观
「解决方案」：
「11.2.3.1 环境代码中文化」：
def convert_environment_to_chinese(environment: str) -> str:
"""将环境代码转换为中文显示"""
environment_map = {
'test': '测试环境',
'prod': '生产环境',
'production': '生产环境',
'dev': '开发环境',
'development': '开发环境',
'staging': '预发布环境',
'uat': '用户验收测试环境',
'sit': '系统集成测试环境'
}
if environment and environment.lower() in environment_map:
return environment_map[environment.lower()]
else:
return environment if environment != 'N/A' else '未知环境'
「11.2.3.2 在邮件模板中使用」：
def create_test_report_html(test_results: dict, project_name: str = "电商平台接口自动化测试") -> str:
# 转换环境代码为中文显示
environment_display = convert_environment_to_chinese(test_results.get('environment', 'N/A'))
# 在HTML模板中使用转换后的环境名称
html_content = f"""
<div class="stat-card">
<div class="stat-number environment">{environment_display}</div>
<div class="stat-label">被测环境</div>
</div>
"""
11.2.4 邮件发送配置管理
「症状」：邮件配置分散在多个文件中，管理困难
「解决方案」：
「11.2.4.1 统一配置管理」：
def get_email_config_from_env() -> dict:
"""从env.yaml中读取邮件配置"""
try:
config_path = PathUtil.CONFIG_DIR / "env.yaml"
with open(config_path, 'r', encoding='utf-8') as f:
config = yaml.safe_load(f)
email_config = config.get('common', {}).get('email', {})
# 验证配置完整性
required_fields = ['recipients', 'primary', 'backup']
for field in required_fields:
if field not in email_config:
raise ValueError(f"邮件配置缺少必要字段: {field}")
# 验证收件人列表
if not email_config['recipients']:
raise ValueError("收件人列表不能为空")
return email_config
except Exception as e:
raise ValueError(f"读取邮件配置失败: {str(e)}")
「11.2.4.2 简化命令行参数」：
# 移除 --email-config 参数，配置统一从 env.yaml 读取
parser.add_argument("--send-email", action="store_true", help="执行完成后发送邮件报告")
parser.add_argument("--email-recipients", nargs="+", default=None, help="邮件收件人列表（可选，覆盖配置文件）")
parser.add_argument("--email-cc", nargs="+", default=None, help="邮件抄送人列表（可选）")
写在最后
限于篇幅考虑，在最初版本的基础上删除了部分基础内容（如Python安装、pytest基础语法、Allure安装步骤等），专注于框架搭建的核心技术和实际应用。如需了解基础知识，建议参考官方文档或相关入门教程。本文档重点展示框架架构设计、工具类实现、钩子函数应用、邮件发送机制、CI/CD集成等进阶内容。
希望本文档对你接口自动化测试工作有所帮助！
扫一扫
380
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
