Test_Agent/tests/model_square/model_square_page.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

676 lines
22 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

"""模型广场页面对象模型"""
from typing import List, Dict, Optional
from playwright.sync_api import Page, Locator
from tests.base.base_page import BasePage
class ModelSquarePage(BasePage):
"""模型广场页面 - /d-cloud/model-square/list"""
# URL和路径
path = "/d-cloud/model-square/list"
# 页面元素选择器
SELECTORS = {
# Tab切换
"preset_tab": ".ant-tabs-tab:has-text('预置模型')",
"private_tab": ".ant-tabs-tab:has-text('私有模型')",
# 操作按钮
"create_model_button": "button:has-text('创建私有模型')",
# 分类筛选
"model_category_filter": ".ant-select[aria-label='模型分类']",
"target_detection": "label:has-text('目标检测')",
"semantic_segmentation": "label:has-text('语义分割')",
"image_classification": "label:has-text('图像分类')",
"depth_estimation": "label:has-text('深度估计')",
# 能力筛选
"capability_filter": ".ant-select[aria-label='能力筛选']",
"training_capability": "label:has-text('训练')",
"inference_capability": "label:has-text('推理')",
"quantization_capability": "label:has-text('量化')",
# 搜索框
"search_input": "input[placeholder*='搜索模型']",
# 模型列表
"model_card": ".ant-card.model-card",
"model_card_header": ".ant-card-head-title",
"model_card_body": ".ant-card-body",
"model_category_tag": ".ant-tag:has-text('目标检测'), .ant-tag:has-text('语义分割'), .ant-tag:has-text('图像分类'), .ant-tag:has-text('深度估计')",
"capability_tag": ".ant-tag:has-text('训练'), .ant-tag:has-text('推理'), .ant-tag:has-text('量化')",
# 空状态
"empty_state": ".ant-empty",
"empty_message": ".ant-empty-description",
# 分页
"pagination": ".ant-pagination",
"next_page": ".ant-pagination-next",
"prev_page": ".ant-pagination-prev",
}
def __init__(self, page: Page):
super().__init__(page)
# 初始化常用元素
self.preset_tab = page.locator(self.SELECTORS["preset_tab"])
self.private_tab = page.locator(self.SELECTORS["private_tab"])
self.create_model_button = page.locator(self.SELECTORS["create_model_button"])
self.search_input = page.locator(self.SELECTORS["search_input"])
self.model_cards = page.locator(self.SELECTORS["model_card"])
def navigate(self, url: Optional[str] = None) -> None:
"""导航到模型广场页面"""
target_url = url if url else f"{self.base_url}{self.path}"
log_ui.debug(f"[导航到模型广场] {target_url}")
self.page.goto(target_url)
self.wait_for_page_ready()
# ==================== Tab切换方法 ====================
def switch_to_preset_models(self) -> bool:
"""切换到预置模型Tab
Returns:
bool: 是否成功切换
"""
try:
if self.is_on_preset_tab():
log_ui.debug("[已经是预置模型Tab,无需切换]")
return True
log_ui.debug("[切换到预置模型]")
self.preset_tab.click()
self.wait_for_page_ready()
return True
except Exception as e:
log_ui.debug(f"[切换到预置模型失败] {e}")
return False
def switch_to_private_models(self) -> bool:
"""切换到私有模型Tab
Returns:
bool: 是否成功切换
"""
try:
if self.is_on_private_tab():
log_ui.debug("[已经是私有模型Tab,无需切换]")
return True
log_ui.debug("[切换到私有模型]")
self.private_tab.click()
self.wait_for_page_ready()
return True
except Exception as e:
log_ui.debug(f"[切换到私有模型失败] {e}")
return False
def is_on_preset_tab(self) -> bool:
"""检查是否在预置模型Tab
Returns:
bool: 是否在预置模型Tab
"""
return self.wait_for_selector_safe(
selector=self.SELECTORS["preset_tab"] + ".ant-tabs-tab-active",
timeout=2000
)
def is_on_private_tab(self) -> bool:
"""检查是否在私有模型Tab
Returns:
bool: 是否在私有模型Tab
"""
return self.wait_for_selector_safe(
selector=self.SELECTORS["private_tab"] + ".ant-tabs-tab-active",
timeout=2000
)
# ==================== 创建模型操作 ====================
def click_create_model(self) -> bool:
"""点击创建私有模型按钮
Returns:
bool: 是否成功点击
"""
return self.click_if_visible(
selector=self.SELECTORS["create_model_button"],
timeout=self.timeout
)
def wait_for_create_model_dialog(self) -> bool:
"""等待创建模型对话框出现
Returns:
bool: 对话框是否可见
"""
return self.wait_until(
condition=lambda: self.page.locator(".ant-modal-content").is_visible(),
timeout=5000
)
# ==================== 分类筛选操作 ====================
def select_model_category(self, category: str) -> bool:
"""选择模型分类
Args:
category: 分类名称 ('目标检测', '语义分割', '图像分类', '深度估计')
Returns:
bool: 是否成功选择
"""
try:
# 打开分类筛选下拉框
category_filter = self.page.locator(self.SELECTORS["model_category_filter"])
if not category_filter.is_visible():
log_ui.debug(f"[分类筛选框不可见]")
return False
category_filter.click()
self.wait(500) # 等待下拉菜单展开
# 选择具体分类
category_map = {
"目标检测": self.SELECTORS["target_detection"],
"语义分割": self.SELECTORS["semantic_segmentation"],
"图像分类": self.SELECTORS["image_classification"],
"深度估计": self.SELECTORS["depth_estimation"]
}
if category not in category_map:
log_ui.debug(f"[未知的分类: {category}]")
return False
category_item = self.page.locator(category_map[category])
if category_item.is_visible():
category_item.click()
self.wait_for_page_ready()
return True
else:
log_ui.debug(f"[分类选项不可见: {category}]")
return False
except Exception as e:
log_ui.debug(f"[选择分类失败] {e}")
return False
def clear_model_category_filter(self) -> bool:
"""清除模型分类筛选
Returns:
bool: 是否成功清除
"""
try:
# 查找已选中的标签
clear_btn = self.page.locator(
self.SELECTORS["model_category_filter"] + " .ant-select-clear"
)
if clear_btn.is_visible():
clear_btn.click()
self.wait_for_page_ready()
return True
return False
except Exception:
return False
def select_capability(self, capability: str) -> bool:
"""选择能力筛选
Args:
capability: 能力名称 ('训练', '推理', '量化')
Returns:
bool: 是否成功选择
"""
try:
# 打开能力筛选下拉框
capability_filter = self.page.locator(self.SELECTORS["capability_filter"])
if not capability_filter.is_visible():
log_ui.debug(f"[能力筛选框不可见]")
return False
capability_filter.click()
self.wait(500) # 等待下拉菜单展开
# 选择具体能力
capability_map = {
"训练": self.SELECTORS["training_capability"],
"推理": self.SELECTORS["inference_capability"],
"量化": self.SELECTORS["quantization_capability"]
}
if capability not in capability_map:
log_ui.debug(f"[未知的能力: {capability}]")
return False
capability_item = self.page.locator(capability_map[capability])
if capability_item.is_visible():
capability_item.click()
self.wait_for_page_ready()
return True
else:
log_ui.debug(f"[能力选项不可见: {capability}]")
return False
except Exception as e:
log_ui.debug(f"[选择能力失败] {e}")
return False
def clear_capability_filter(self) -> bool:
"""清除能力筛选
Returns:
bool: 是否成功清除
"""
try:
# 查找已选中的标签
clear_btn = self.page.locator(
self.SELECTORS["capability_filter"] + " .ant-select-clear"
)
if clear_btn.is_visible():
clear_btn.click()
self.wait_for_page_ready()
return True
return False
except Exception:
return False
# ==================== 搜索操作 ====================
def search_model(self, keyword: str) -> bool:
"""搜索模型
Args:
keyword: 搜索关键词
Returns:
bool: 是否成功搜索
"""
try:
if self.search_input.is_visible():
self.search_input.fill(keyword)
self.page.keyboard.press("Enter")
self.wait_for_page_ready()
return True
return False
except Exception:
return False
def clear_search(self) -> bool:
"""清除搜索框
Returns:
bool: 是否成功清除
"""
try:
if self.search_input.is_visible():
self.search_input.clear()
self.page.keyboard.press("Enter")
self.wait_for_page_ready()
return True
return False
except Exception:
return False
# ==================== 模型列表操作 ====================
def has_models(self) -> bool:
"""检查是否有模型
Returns:
bool: 是否有模型
"""
# 检查是否有空状态
empty_state = self.page.locator(self.SELECTORS["empty_state"])
if empty_state.is_visible():
return False
# 检查是否有模型卡片
return self.wait_for_selector_safe(
selector=self.SELECTORS["model_card"],
timeout=3000
)
def get_model_count(self) -> int:
"""获取模型数量
Returns:
int: 模型数量
"""
try:
if not self.has_models():
return 0
return self.model_cards.count()
except Exception:
return 0
def get_model_list(self) -> List[Dict[str, str]]:
"""获取模型列表
Returns:
List[Dict[str, str]]: 模型信息列表
"""
models = []
try:
if not self.has_models():
return models
# 等待模型卡片加载
self.wait_for_element(self.SELECTORS["model_card"], timeout=5000)
cards = self.model_cards.all()
for card in cards:
try:
model_info = {"name": "", "category": [], "capabilities": []}
# 获取模型名称
header = card.locator(self.SELECTORS["model_card_header"])
if header.is_visible():
name = header.text_content()
if name:
model_info["name"] = name.strip()
# 获取模型分类标签
category_tags = card.locator(self.SELECTORS["model_category_tag"])
for tag in category_tags.all():
category = tag.text_content()
if category:
model_info["category"].append(category.strip())
# 获取能力标签
capability_tags = card.locator(self.SELECTORS["capability_tag"])
for tag in capability_tags.all():
capability = tag.text_content()
if capability:
model_info["capabilities"].append(capability.strip())
if model_info["name"]:
models.append(model_info)
except Exception:
continue
except Exception as e:
log_ui.debug(f"[获取模型列表失败] {e}")
return models
def get_model_categories(self) -> List[str]:
"""获取页面中显示的模型分类列表
Returns:
List[str]: 分类列表
"""
categories = []
try:
# 从筛选器中获取
category_filter = self.page.locator(self.SELECTORS["model_category_filter"])
if category_filter.is_visible():
# 获取下拉菜单中的选项
category_filter.click()
self.wait(300)
# 查找所有分类选项
options = self.page.locator(
".ant-select-dropdown .ant-select-item-option"
).all()
for option in options:
text = option.text_content()
if text and text.strip():
categories.append(text.strip())
# 关闭下拉菜单
self.page.keyboard.press("Escape")
self.wait(200)
except Exception:
pass
return categories
def get_model_capabilities(self) -> List[str]:
"""获取页面中显示的模型能力列表
Returns:
List[str]: 能力列表
"""
capabilities = []
try:
# 从筛选器中获取
capability_filter = self.page.locator(self.SELECTORS["capability_filter"])
if capability_filter.is_visible():
# 获取下拉菜单中的选项
capability_filter.click()
self.wait(300)
# 查找所有能力选项
options = self.page.locator(
".ant-select-dropdown .ant-select-item-option"
).all()
for option in options:
text = option.text_content()
if text and text.strip():
capabilities.append(text.strip())
# 关闭下拉菜单
self.page.keyboard.press("Escape")
self.wait(200)
except Exception:
pass
return capabilities
def click_model_by_name(self, model_name: str) -> bool:
"""点击指定名称的模型卡片
Args:
model_name: 模型名称
Returns:
bool: 是否成功点击
"""
try:
model_card = self.page.locator(
f"{self.SELECTORS['model_card']}:has-text('{model_name}')"
)
if model_card.is_visible():
model_card.click()
self.wait_for_page_ready()
return True
return False
except Exception:
return False
def get_model_details(self, model_name: str) -> Optional[Dict[str, str]]:
"""获取指定模型的详细信息
Args:
model_name: 模型名称
Returns:
Optional[Dict[str, str]]: 模型详细信息
"""
try:
model_card = self.page.locator(
f"{self.SELECTORS['model_card']}:has-text('{model_name}')"
)
if not model_card.is_visible():
return None
details = {"name": model_name}
# 获取描述信息
body = model_card.locator(self.SELECTORS["model_card_body"])
if body.is_visible():
body_text = body.text_content()
if body_text:
details["description"] = body_text.strip()
# 获取分类
categories = []
category_tags = model_card.locator(self.SELECTORS["model_category_tag"])
for tag in category_tags.all():
category = tag.text_content()
if category:
categories.append(category.strip())
if categories:
details["categories"] = categories
# 获取能力
capabilities = []
capability_tags = model_card.locator(self.SELECTORS["capability_tag"])
for tag in capability_tags.all():
capability = tag.text_content()
if capability:
capabilities.append(capability.strip())
if capabilities:
details["capabilities"] = capabilities
return details
except Exception:
return None
# ==================== 分页操作 ====================
def has_pagination(self) -> bool:
"""检查是否有分页
Returns:
bool: 是否有分页
"""
try:
return self.page.locator(self.SELECTORS["pagination"]).is_visible()
except Exception:
return False
def click_next_page(self) -> bool:
"""点击下一页
Returns:
bool: 是否成功点击
"""
try:
next_btn = self.page.locator(self.SELECTORS["next_page"])
if next_btn.is_visible() and next_btn.is_enabled():
next_btn.click()
self.wait_for_page_ready()
return True
return False
except Exception:
return False
def click_prev_page(self) -> bool:
"""点击上一页
Returns:
bool: 是否成功点击
"""
try:
prev_btn = self.page.locator(self.SELECTORS["prev_page"])
if prev_btn.is_visible() and prev_btn.is_enabled():
prev_btn.click()
self.wait_for_page_ready()
return True
return False
except Exception:
return False
def go_to_page(self, page_num: int) -> bool:
"""跳转到指定页码
Args:
page_num: 页码
Returns:
bool: 是否成功跳转
"""
try:
page_item = self.page.locator(
f"{self.SELECTORS['pagination']} .ant-pagination-item:has-text('{page_num}')"
)
if page_item.is_visible():
page_item.click()
self.wait_for_page_ready()
return True
return False
except Exception:
return False
def get_current_page(self) -> Optional[int]:
"""获取当前页码
Returns:
Optional[int]: 当前页码,获取失败返回None
"""
try:
current_page = self.page.locator(
f"{self.SELECTORS['pagination']} .ant-pagination-item-active"
)
if current_page.is_visible():
text = current_page.text_content()
if text:
return int(text.strip())
except Exception:
pass
return None
# ==================== 页面状态检查 ====================
def wait_for_model_list_loaded(self, timeout: int = 10000) -> bool:
"""等待模型列表加载完成
Args:
timeout: 超时时间(毫秒)
Returns:
bool: 是否加载完成
"""
return self.wait_until(
condition=lambda: self.has_models(),
timeout=timeout
)
def is_model_visible(self, model_name: str) -> bool:
"""检查模型是否可见
Args:
model_name: 模型名称
Returns:
bool: 是否可见
"""
try:
model_card = self.page.locator(
f"{self.SELECTORS['model_card']}:has-text('{model_name}')"
)
return model_card.is_visible()
except Exception:
return False
def wait_for_model_visible(self, model_name: str, timeout: int = 10000) -> bool:
"""等待模型可见
Args:
model_name: 模型名称
timeout: 超时时间(毫秒)
Returns:
bool: 是否可见
"""
return self.wait_until(
condition=lambda: self.is_model_visible(model_name),
timeout=timeout
)
# 导入日志模块
from tests.logger import log_ui