- 16 个业务模块,856 个测试用例,40 个 E2E 测试 - 单一 React 19 前端 + PlatformSwitcher 二合一切换 - Flask 后端支持 scenario/dcloud_module/dcloud_e2e/dcloud_all 四种任务类型 - E2E 测试面板:API 全链路(8条) + UI 点击(3条) + 分步测试(3个) - SSE 实时日志流 + 飞书告警 + 定时调度 - 完整还原原 ToB 平台 TestPanel E2E 模块
465 lines
14 KiB
Python
465 lines
14 KiB
Python
"""
|
|
业务断言库
|
|
|
|
提供业务特定的断言方法,增强测试验证能力。
|
|
|
|
特性:
|
|
- 业务场景特定的断言
|
|
- JSON Schema 验证
|
|
- 详细的错误信息
|
|
- 断言结果收集
|
|
|
|
使用示例:
|
|
from tests.utils.business_assertions import BusinessAssertions
|
|
|
|
assertions = BusinessAssertions(page)
|
|
|
|
# 断言数据集创建成功
|
|
assertions.assert_dataset_created(dataset_info)
|
|
|
|
# 断言 API 响应有效
|
|
assertions.assert_api_response_valid(response, schema)
|
|
|
|
# 断言列表非空
|
|
assertions.assert_list_not_empty(items, "数据集列表")
|
|
"""
|
|
import json
|
|
from typing import Any, Dict, List, Optional
|
|
from playwright.sync_api import Page
|
|
from tests.logger import get_logger
|
|
|
|
_logger = get_logger("ASSERTIONS")
|
|
|
|
|
|
class BusinessAssertions:
|
|
"""业务断言类
|
|
|
|
提供业务场景特定的断言方法。
|
|
"""
|
|
|
|
def __init__(self, page: Optional[Page] = None):
|
|
"""初始化断言器
|
|
|
|
Args:
|
|
page: Playwright Page 对象(可选)
|
|
"""
|
|
self.page = page
|
|
self._assertion_results: List[Dict[str, Any]] = []
|
|
|
|
def _record_result(
|
|
self,
|
|
assertion_type: str,
|
|
passed: bool,
|
|
message: str,
|
|
details: Optional[Dict[str, Any]] = None
|
|
) -> None:
|
|
"""记录断言结果
|
|
|
|
Args:
|
|
assertion_type: 断言类型
|
|
passed: 是否通过
|
|
message: 断言消息
|
|
details: 详细信息
|
|
"""
|
|
self._assertion_results.append({
|
|
"type": assertion_type,
|
|
"passed": passed,
|
|
"message": message,
|
|
"details": details or {}
|
|
})
|
|
|
|
def get_results(self) -> List[Dict[str, Any]]:
|
|
"""获取所有断言结果
|
|
|
|
Returns:
|
|
List[Dict[str, Any]]: 断言结果列表
|
|
"""
|
|
return self._assertion_results
|
|
|
|
def get_passed_count(self) -> int:
|
|
"""获取通过的断言数量
|
|
|
|
Returns:
|
|
int: 通过的断言数量
|
|
"""
|
|
return sum(1 for r in self._assertion_results if r["passed"])
|
|
|
|
def get_failed_count(self) -> int:
|
|
"""获取失败的断言数量
|
|
|
|
Returns:
|
|
int: 失败的断言数量
|
|
"""
|
|
return sum(1 for r in self._assertion_results if not r["passed"])
|
|
|
|
# ==================== 通用断言 ====================
|
|
|
|
def assert_true(
|
|
self,
|
|
condition: bool,
|
|
message: str = "条件应为 True"
|
|
) -> None:
|
|
"""断言条件为 True
|
|
|
|
Args:
|
|
condition: 条件
|
|
message: 断言消息
|
|
"""
|
|
passed = condition is True
|
|
self._record_result("assert_true", passed, message)
|
|
assert passed, message
|
|
|
|
def assert_false(
|
|
self,
|
|
condition: bool,
|
|
message: str = "条件应为 False"
|
|
) -> None:
|
|
"""断言条件为 False
|
|
|
|
Args:
|
|
condition: 条件
|
|
message: 断言消息
|
|
"""
|
|
passed = condition is False
|
|
self._record_result("assert_false", passed, message)
|
|
assert passed, message
|
|
|
|
def assert_equal(
|
|
self,
|
|
actual: Any,
|
|
expected: Any,
|
|
message: str = None
|
|
) -> None:
|
|
"""断言两个值相等
|
|
|
|
Args:
|
|
actual: 实际值
|
|
expected: 期望值
|
|
message: 断言消息
|
|
"""
|
|
message = message or f"期望值: {expected}, 实际值: {actual}"
|
|
passed = actual == expected
|
|
self._record_result("assert_equal", passed, message, {"actual": actual, "expected": expected})
|
|
assert passed, message
|
|
|
|
def assert_not_equal(
|
|
self,
|
|
actual: Any,
|
|
expected: Any,
|
|
message: str = None
|
|
) -> None:
|
|
"""断言两个值不相等
|
|
|
|
Args:
|
|
actual: 实际值
|
|
expected: 期望值
|
|
message: 断言消息
|
|
"""
|
|
message = message or f"值不应等于: {expected}"
|
|
passed = actual != expected
|
|
self._record_result("assert_not_equal", passed, message)
|
|
assert passed, message
|
|
|
|
def assert_in(
|
|
self,
|
|
item: Any,
|
|
container: Any,
|
|
message: str = None
|
|
) -> None:
|
|
"""断言项在容器中
|
|
|
|
Args:
|
|
item: 项
|
|
container: 容器
|
|
message: 断言消息
|
|
"""
|
|
message = message or f"{item} 应在容器中"
|
|
passed = item in container
|
|
self._record_result("assert_in", passed, message)
|
|
assert passed, message
|
|
|
|
def assert_not_in(
|
|
self,
|
|
item: Any,
|
|
container: Any,
|
|
message: str = None
|
|
) -> None:
|
|
"""断言项不在容器中
|
|
|
|
Args:
|
|
item: 项
|
|
container: 容器
|
|
message: 断言消息
|
|
"""
|
|
message = message or f"{item} 不应在容器中"
|
|
passed = item not in container
|
|
self._record_result("assert_not_in", passed, message)
|
|
assert passed, message
|
|
|
|
def assert_list_not_empty(
|
|
self,
|
|
items: List[Any],
|
|
list_name: str = "列表"
|
|
) -> None:
|
|
"""断言列表非空
|
|
|
|
Args:
|
|
items: 列表
|
|
list_name: 列表名称
|
|
"""
|
|
message = f"{list_name} 不应为空"
|
|
passed = bool(items) and len(items) > 0
|
|
self._record_result("assert_list_not_empty", passed, message, {"count": len(items)})
|
|
assert passed, message
|
|
|
|
def assert_list_count(
|
|
self,
|
|
items: List[Any],
|
|
expected_count: int,
|
|
list_name: str = "列表"
|
|
) -> None:
|
|
"""断言列表数量
|
|
|
|
Args:
|
|
items: 列表
|
|
expected_count: 预期数量
|
|
list_name: 列表名称
|
|
"""
|
|
actual_count = len(items)
|
|
message = f"{list_name} 数量应为 {expected_count}, 实际为 {actual_count}"
|
|
passed = actual_count == expected_count
|
|
self._record_result("assert_list_count", passed, message, {"actual": actual_count, "expected": expected_count})
|
|
assert passed, message
|
|
|
|
# ==================== API 断言 ====================
|
|
|
|
def assert_api_success(
|
|
self,
|
|
response: Any,
|
|
message: str = "API 请求应成功"
|
|
) -> None:
|
|
"""断言 API 请求成功
|
|
|
|
Args:
|
|
response: API 响应对象(需要有 status_code 属性)
|
|
message: 断言消息
|
|
"""
|
|
status_code = getattr(response, "status_code", None)
|
|
passed = status_code is not None and 200 <= status_code < 300
|
|
self._record_result("assert_api_success", passed, message, {"status_code": status_code})
|
|
assert passed, f"{message}, 状态码: {status_code}"
|
|
|
|
def assert_api_response_valid(
|
|
self,
|
|
response: Any,
|
|
expected_fields: List[str] = None,
|
|
message: str = "API 响应应有效"
|
|
) -> None:
|
|
"""断言 API 响应有效
|
|
|
|
Args:
|
|
response: API 响应对象
|
|
expected_fields: 期望的字段列表
|
|
message: 断言消息
|
|
"""
|
|
try:
|
|
data = response.json() if hasattr(response, "json") else response
|
|
|
|
# 检查响应不为空
|
|
assert data is not None, "响应数据不应为空"
|
|
|
|
# 检查期望字段
|
|
if expected_fields:
|
|
missing_fields = []
|
|
for field in expected_fields:
|
|
if field not in data:
|
|
missing_fields.append(field)
|
|
|
|
assert not missing_fields, f"缺少字段: {missing_fields}"
|
|
|
|
self._record_result("assert_api_response_valid", True, message)
|
|
except Exception as e:
|
|
self._record_result("assert_api_response_valid", False, message, {"error": str(e)})
|
|
raise
|
|
|
|
def assert_api_error(
|
|
self,
|
|
response: Any,
|
|
expected_status: int = None,
|
|
expected_error_code: str = None,
|
|
message: str = "API 应返回错误"
|
|
) -> None:
|
|
"""断言 API 返回错误
|
|
|
|
Args:
|
|
response: API 响应对象
|
|
expected_status: 期望的状态码
|
|
expected_error_code: 期望的错误代码
|
|
message: 断言消息
|
|
"""
|
|
status_code = getattr(response, "status_code", None)
|
|
|
|
# 检查状态码
|
|
if expected_status:
|
|
assert status_code == expected_status, f"状态码应为 {expected_status}, 实际为 {status_code}"
|
|
else:
|
|
assert status_code >= 400, f"状态码应 >= 400, 实际为 {status_code}"
|
|
|
|
# 检查错误代码
|
|
if expected_error_code:
|
|
try:
|
|
data = response.json() if hasattr(response, "json") else {}
|
|
error_code = data.get("code") or data.get("error_code")
|
|
assert error_code == expected_error_code, f"错误代码应为 {expected_error_code}, 实际为 {error_code}"
|
|
except Exception:
|
|
pass
|
|
|
|
self._record_result("assert_api_error", True, message)
|
|
|
|
# ==================== UI 断言 ====================
|
|
|
|
def assert_element_visible(
|
|
self,
|
|
selector: str,
|
|
message: str = None
|
|
) -> None:
|
|
"""断言元素可见
|
|
|
|
Args:
|
|
selector: 元素选择器
|
|
message: 断言消息
|
|
"""
|
|
if not self.page:
|
|
raise ValueError("Page 对象未初始化")
|
|
|
|
message = message or f"元素应可见: {selector}"
|
|
is_visible = self.page.locator(selector).is_visible()
|
|
|
|
self._record_result("assert_element_visible", is_visible, message)
|
|
assert is_visible, message
|
|
|
|
def assert_element_hidden(
|
|
self,
|
|
selector: str,
|
|
message: str = None
|
|
) -> None:
|
|
"""断言元素隐藏
|
|
|
|
Args:
|
|
selector: 元素选择器
|
|
message: 断言消息
|
|
"""
|
|
if not self.page:
|
|
raise ValueError("Page 对象未初始化")
|
|
|
|
message = message or f"元素应隐藏: {selector}"
|
|
is_hidden = self.page.locator(selector).is_hidden()
|
|
|
|
self._record_result("assert_element_hidden", is_hidden, message)
|
|
assert is_hidden, message
|
|
|
|
def assert_element_text(
|
|
self,
|
|
selector: str,
|
|
expected_text: str,
|
|
message: str = None
|
|
) -> None:
|
|
"""断言元素文本
|
|
|
|
Args:
|
|
selector: 元素选择器
|
|
expected_text: 期望文本
|
|
message: 断言消息
|
|
"""
|
|
if not self.page:
|
|
raise ValueError("Page 对象未初始化")
|
|
|
|
actual_text = self.page.locator(selector).inner_text()
|
|
message = message or f"元素文本应为: {expected_text}, 实际为: {actual_text}"
|
|
|
|
passed = actual_text == expected_text
|
|
self._record_result("assert_element_text", passed, message, {"actual": actual_text, "expected": expected_text})
|
|
assert passed, message
|
|
|
|
def assert_url_contains(
|
|
self,
|
|
url_part: str,
|
|
message: str = None
|
|
) -> None:
|
|
"""断言 URL 包含指定部分
|
|
|
|
Args:
|
|
url_part: URL 部分
|
|
message: 断言消息
|
|
"""
|
|
if not self.page:
|
|
raise ValueError("Page 对象未初始化")
|
|
|
|
current_url = self.page.url
|
|
message = message or f"URL 应包含: {url_part}"
|
|
|
|
passed = url_part in current_url
|
|
self._record_result("assert_url_contains", passed, message, {"url": current_url})
|
|
assert passed, message
|
|
|
|
# ==================== 业务断言 ====================
|
|
|
|
def assert_dataset_created(
|
|
self,
|
|
dataset_info: Dict[str, Any],
|
|
message: str = "数据集应创建成功"
|
|
) -> None:
|
|
"""断言数据集创建成功
|
|
|
|
Args:
|
|
dataset_info: 数据集信息
|
|
message: 断言消息
|
|
"""
|
|
# 检查必要字段
|
|
required_fields = ["id", "name"]
|
|
missing_fields = [f for f in required_fields if f not in dataset_info]
|
|
|
|
passed = not missing_fields
|
|
self._record_result("assert_dataset_created", passed, message, {"missing_fields": missing_fields})
|
|
assert passed, f"{message}, 缺少字段: {missing_fields}"
|
|
|
|
def assert_task_created(
|
|
self,
|
|
task_info: Dict[str, Any],
|
|
message: str = "任务应创建成功"
|
|
) -> None:
|
|
"""断言任务创建成功
|
|
|
|
Args:
|
|
task_info: 任务信息
|
|
message: 断言消息
|
|
"""
|
|
required_fields = ["id", "name", "status"]
|
|
missing_fields = [f for f in required_fields if f not in task_info]
|
|
|
|
passed = not missing_fields
|
|
self._record_result("assert_task_created", passed, message, {"missing_fields": missing_fields})
|
|
assert passed, f"{message}, 缺少字段: {missing_fields}"
|
|
|
|
|
|
# 便捷函数
|
|
def assert_response_ok(response: Any) -> None:
|
|
"""便捷函数:断言响应成功
|
|
|
|
Args:
|
|
response: API 响应对象
|
|
"""
|
|
assertions = BusinessAssertions()
|
|
assertions.assert_api_success(response)
|
|
|
|
|
|
def assert_list_not_empty(items: List[Any], list_name: str = "列表") -> None:
|
|
"""便捷函数:断言列表非空
|
|
|
|
Args:
|
|
items: 列表
|
|
list_name: 列表名称
|
|
"""
|
|
assertions = BusinessAssertions()
|
|
assertions.assert_list_not_empty(items, list_name)
|