TBC/tests/utils/business_assertions.py
jiawei.chen 6f6053ff51 feat: TestAgent 智能测试平台 v1.0
- CLI + Web 双平台,基于 LLM 的 TDD+DDD 自动化测试生成
- 集成 unified-test-platform 903 个 D-Cloud 用例 + 13 个 Robogo 场景
- Agent 5 步流水线: 扫描 -> DDD -> LLM 生成测试
- 精确回归 + UI 变更检查
- 可视化 HTML 测试报告
- 暗色/亮色主题切换
- 19 个 API 端点 + 6 个 SPA 页面
- 15/15 项 TDD+DDD 合规
2026-07-08 11:27:38 +08:00

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)