- 15个文件添加 from __future__ import annotations 修复 Python 3.9 管道语法 - DCloudDashboard 首页新增总览分组,E2E 全量测试入口卡片 - 同步更新 README/history/测试用例文档
1457 lines
57 KiB
Python
1457 lines
57 KiB
Python
"""
|
||
数据生成模块Page Object
|
||
|
||
封装数据生成模块的UI元素和操作
|
||
拆分为 TaskListPage(任务列表)和 WorkflowSelectionPage(工作流选择/任务创建)
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
from playwright.sync_api import Page, Locator
|
||
from tests.base.base_page import BasePage
|
||
from tests.logger import log_ui
|
||
|
||
|
||
class TaskListPage(BasePage):
|
||
"""数据生成 - 任务列表页面"""
|
||
|
||
# 页面URL
|
||
url = "https://cloud-fat.d-robotics.cc/d-cloud/data-create/list"
|
||
|
||
# 元素选择器
|
||
SELECTORS = {
|
||
# 导航相关
|
||
"nav_workbench": "button:has-text('工作台')",
|
||
"sidebar_data_gen": "span:has-text('数据生成'):visible",
|
||
# 任务列表相关
|
||
"create_task_button": "button:has-text('创建任务')",
|
||
"task_table": ".ant-table",
|
||
"task_table_rows": ".ant-table-tbody tr",
|
||
"task_table_headers": ".ant-table-thead th",
|
||
"task_name_column": "td:nth-child(1)",
|
||
"task_status_column": "td:nth-child(2)",
|
||
"task_action_column": "td:nth-child(8)",
|
||
# 分页相关
|
||
"pagination": ".ant-pagination",
|
||
"pagination_next": ".ant-pagination-next",
|
||
"pagination_prev": ".ant-pagination-prev",
|
||
"pagination_total": ".ant-pagination-total-text",
|
||
# 状态相关
|
||
"loading_spinner": ".ant-spin",
|
||
"empty_state": ".ant-empty",
|
||
# 操作按钮
|
||
"debug_button": "button:has-text('调试')",
|
||
"detail_button": "td:first-child a",
|
||
"delete_button": "button:has-text('删除')",
|
||
"clone_button": "button:has-text('克隆')",
|
||
# 搜索功能
|
||
"search_input": "input[placeholder*='搜索'], input[placeholder*='Search']",
|
||
"search_clear": "span.ant-input-clear-icon",
|
||
# 筛选功能
|
||
"status_filter": ".ant-select:has-text('状态'), .ant-select-selection-item:has-text('状态')",
|
||
"workflow_filter": ".ant-select:has-text('工作流'), .ant-select-selection-item:has-text('工作流')",
|
||
"clear_filter_button": "button:has-text('重置'), button:has-text('清空'), .ant-btn:has-text('清除')",
|
||
# 排序功能
|
||
"sortable_column": ".ant-table-column-sorter",
|
||
# 批量操作
|
||
"select_all_checkbox": "th .ant-checkbox-wrapper",
|
||
"task_checkbox": "td .ant-checkbox-wrapper",
|
||
"batch_actions": ".ant-dropdown-trigger:has-text('批量操作')",
|
||
"batch_delete": ".ant-dropdown-menu-item:has-text('删除')",
|
||
"batch_stop": ".ant-dropdown-menu-item:has-text('停止')",
|
||
# 刷新按钮
|
||
"refresh_button": "button:has-text('刷新'), .ant-btn-icon-only:has(svg)",
|
||
}
|
||
|
||
def __init__(self, page: Page):
|
||
super().__init__(page)
|
||
|
||
def navigate_to_data_generation(self):
|
||
"""导航到数据生成页面"""
|
||
self.navigate(self.url)
|
||
self.wait_for_table_load()
|
||
|
||
def click_create_task(self) -> "WorkflowSelectionPage":
|
||
"""点击创建任务按钮,返回工作流选择页面"""
|
||
self.click(self.SELECTORS["create_task_button"])
|
||
try:
|
||
self.page.wait_for_url("**/d-cloud/data-create/create", timeout=10000)
|
||
except Exception:
|
||
pass
|
||
self.wait_for_load_state("networkidle")
|
||
return WorkflowSelectionPage(self.page)
|
||
|
||
def get_table_headers(self) -> list[str]:
|
||
"""获取表格列头"""
|
||
headers = self.page.locator(
|
||
self.SELECTORS["task_table_headers"]
|
||
).all_inner_texts()
|
||
return headers if headers else []
|
||
|
||
def get_table_row_count(self) -> int:
|
||
"""获取表格行数"""
|
||
self.page.wait_for_selector(self.SELECTORS["task_table"], timeout=self.timeout)
|
||
return self.page.locator(self.SELECTORS["task_table_rows"]).count()
|
||
|
||
def get_all_task_names(self) -> list[str]:
|
||
"""获取所有任务名称"""
|
||
rows = self.page.locator(self.SELECTORS["task_table_rows"]).all()
|
||
names = []
|
||
for row in rows:
|
||
try:
|
||
name = row.locator(self.SELECTORS["task_name_column"]).inner_text()
|
||
names.append(name)
|
||
except Exception:
|
||
pass
|
||
return names
|
||
|
||
def get_task_by_name(self, task_name: str) -> Locator | None:
|
||
"""根据名称获取任务行"""
|
||
rows = self.page.locator(self.SELECTORS["task_table_rows"]).all()
|
||
for row in rows:
|
||
try:
|
||
name = row.locator(self.SELECTORS["task_name_column"]).inner_text()
|
||
if task_name in name:
|
||
return row
|
||
except Exception:
|
||
pass
|
||
return None
|
||
|
||
def click_task_debug(self, task_name: str):
|
||
"""点击任务的调试按钮"""
|
||
row = self.get_task_by_name(task_name)
|
||
if row:
|
||
debug_btn = row.locator("button:has-text('调试')")
|
||
if debug_btn.is_visible():
|
||
debug_btn.click()
|
||
self.page.wait_for_load_state("networkidle")
|
||
|
||
def click_task_detail(self, task_name: str):
|
||
"""点击任务名称链接进入详情页"""
|
||
row = self.get_task_by_name(task_name)
|
||
if row:
|
||
task_name_link = row.locator("td:first-child a")
|
||
if task_name_link.is_visible():
|
||
task_name_link.click()
|
||
try:
|
||
self.page.wait_for_url("**/d-cloud/data-create/taskdetail/**", timeout=10000)
|
||
except Exception:
|
||
pass
|
||
self._safe_wait_network_idle()
|
||
|
||
def click_task_delete(self, task_name: str):
|
||
"""点击任务的删除按钮"""
|
||
row = self.get_task_by_name(task_name)
|
||
if row:
|
||
delete_btn = row.locator("button:has-text('删除')")
|
||
if delete_btn.is_visible():
|
||
delete_btn.click()
|
||
# 等待确认对话框
|
||
self.page.wait_for_selector(".ant-modal", timeout=5000)
|
||
|
||
def click_task_clone(self, task_name: str):
|
||
"""点击任务的克隆按钮"""
|
||
row = self.get_task_by_name(task_name)
|
||
if row:
|
||
clone_btn = row.locator("button:has-text('克隆')")
|
||
if clone_btn.is_visible():
|
||
clone_btn.click()
|
||
self.page.wait_for_load_state("networkidle")
|
||
|
||
def click_next_page(self):
|
||
"""点击下一页"""
|
||
self.click(self.SELECTORS["pagination_next"])
|
||
self.page.wait_for_load_state("networkidle")
|
||
|
||
def click_prev_page(self):
|
||
"""点击上一页"""
|
||
self.click(self.SELECTORS["pagination_prev"])
|
||
self.page.wait_for_load_state("networkidle")
|
||
|
||
def wait_for_table_load(self):
|
||
"""等待表格加载完成"""
|
||
# 表格可能不存在(空状态),使用try-except处理
|
||
try:
|
||
self.page.wait_for_selector(self.SELECTORS["task_table"], timeout=10000)
|
||
except Exception:
|
||
# 表格不存在,可能是空状态或页面结构变化
|
||
pass
|
||
# 等待加载状态消失
|
||
try:
|
||
self.page.wait_for_selector(
|
||
self.SELECTORS["loading_spinner"], state="hidden", timeout=5000
|
||
)
|
||
except Exception:
|
||
pass
|
||
|
||
def has_data(self) -> bool:
|
||
"""检查是否有数据"""
|
||
return self.get_table_row_count() > 0
|
||
|
||
def is_empty(self) -> bool:
|
||
"""检查是否为空状态"""
|
||
return self.is_visible(self.SELECTORS["empty_state"])
|
||
|
||
def get_task_status(self, task_name: str) -> str | None:
|
||
"""获取任务状态"""
|
||
row = self.get_task_by_name(task_name)
|
||
if row:
|
||
return row.locator(self.SELECTORS["task_status_column"]).inner_text()
|
||
return None
|
||
|
||
def assert_data_generation_loaded(self):
|
||
"""验证数据生成页面加载成功"""
|
||
from playwright.sync_api import expect
|
||
|
||
expect(self.page.locator(self.SELECTORS["task_table"])).to_be_visible()
|
||
expect(self.page.locator(self.SELECTORS["create_task_button"])).to_be_visible()
|
||
|
||
def get_pagination_text(self) -> str:
|
||
"""获取分页文本"""
|
||
return self.page.locator(self.SELECTORS["pagination_total"]).inner_text()
|
||
|
||
# ==================== 搜索功能 ====================
|
||
|
||
def search_tasks(self, keyword: str) -> bool:
|
||
"""搜索任务
|
||
|
||
Args:
|
||
keyword: 搜索关键词
|
||
|
||
Returns:
|
||
bool: 是否成功执行搜索
|
||
"""
|
||
try:
|
||
log_ui.debug(f"[搜索] 关键字: '{keyword}'")
|
||
# 调用基类的通用搜索方法
|
||
result = super().search(keyword, placeholder="搜索")
|
||
if result:
|
||
self.wait_for_table_load()
|
||
log_ui.debug(f"[搜索成功] 关键字: '{keyword}'")
|
||
else:
|
||
log_ui.debug(f"[搜索失败] 未找到搜索框,关键字: '{keyword}'")
|
||
return result
|
||
except Exception as e:
|
||
log_ui.error(f"[搜索异常] 关键字 '{keyword}': {str(e)}")
|
||
return False
|
||
|
||
def clear_search(self) -> bool:
|
||
"""清空搜索
|
||
|
||
Returns:
|
||
bool: 是否成功清空搜索
|
||
"""
|
||
try:
|
||
log_ui.debug("[清空搜索]")
|
||
# 调用基类的通用清除搜索方法
|
||
result = super().clear_search(placeholder="搜索")
|
||
if result:
|
||
self.wait_for_table_load()
|
||
log_ui.debug("[清空搜索成功]")
|
||
else:
|
||
# 尝试清除搜索框内容
|
||
search_input = self.find(self.SELECTORS["search_input"])
|
||
if search_input.is_visible():
|
||
search_input.clear()
|
||
self.page.keyboard.press("Enter")
|
||
self.wait_for_table_load()
|
||
log_ui.debug("[通过输入框清空搜索成功]")
|
||
return True
|
||
log_ui.debug("[清空搜索失败] 未找到搜索框")
|
||
return result
|
||
except Exception as e:
|
||
log_ui.error(f"[清空搜索异常]: {str(e)}")
|
||
return False
|
||
|
||
# ==================== 筛选功能 ====================
|
||
|
||
def filter_by_status(self, status: str) -> bool:
|
||
"""按状态筛选任务(执行中/成功/失败/等待中)
|
||
|
||
Args:
|
||
status: 状态值
|
||
|
||
Returns:
|
||
bool: 是否成功筛选
|
||
"""
|
||
try:
|
||
log_ui.debug(f"[筛选状态] 状态: '{status}'")
|
||
|
||
# 点击状态筛选器
|
||
status_locator = self.find(self.SELECTORS["status_filter"])
|
||
if not status_locator.is_visible():
|
||
log_ui.debug("[筛选状态] 未找到状态筛选器")
|
||
return False
|
||
|
||
status_locator.click()
|
||
self.wait(500) # 等待下拉菜单打开
|
||
|
||
# 选择状态选项
|
||
dropdown_item = self.page.locator(f".ant-select-dropdown .ant-select-item:has-text('{status}')")
|
||
if dropdown_item.is_visible():
|
||
dropdown_item.click()
|
||
self.wait_for_table_load()
|
||
log_ui.debug(f"[筛选状态成功] 状态: '{status}'")
|
||
return True
|
||
else:
|
||
log_ui.debug(f"[筛选状态失败] 状态选项不存在: '{status}'")
|
||
return False
|
||
except Exception as e:
|
||
log_ui.error(f"[筛选状态异常] 状态 '{status}': {str(e)}")
|
||
return False
|
||
|
||
def filter_by_workflow(self, workflow_name: str) -> bool:
|
||
"""按工作流筛选
|
||
|
||
Args:
|
||
workflow_name: 工作流名称
|
||
|
||
Returns:
|
||
bool: 是否成功筛选
|
||
"""
|
||
try:
|
||
log_ui.debug(f"[筛选工作流] 工作流: '{workflow_name}'")
|
||
|
||
# 点击工作流筛选器
|
||
workflow_locator = self.find(self.SELECTORS["workflow_filter"])
|
||
if not workflow_locator.is_visible():
|
||
log_ui.debug("[筛选工作流] 未找到工作流筛选器")
|
||
return False
|
||
|
||
workflow_locator.click()
|
||
self.wait(500) # 等待下拉菜单打开
|
||
|
||
# 选择工作流选项
|
||
dropdown_item = self.page.locator(f".ant-select-dropdown .ant-select-item:has-text('{workflow_name}')")
|
||
if dropdown_item.is_visible():
|
||
dropdown_item.click()
|
||
self.wait_for_table_load()
|
||
log_ui.debug(f"[筛选工作流成功] 工作流: '{workflow_name}'")
|
||
return True
|
||
else:
|
||
log_ui.debug(f"[筛选工作流失败] 工作流选项不存在: '{workflow_name}'")
|
||
return False
|
||
except Exception as e:
|
||
log_ui.error(f"[筛选工作流异常] 工作流 '{workflow_name}': {str(e)}")
|
||
return False
|
||
|
||
def clear_filters(self) -> bool:
|
||
"""清空筛选
|
||
|
||
Returns:
|
||
bool: 是否成功清空筛选
|
||
"""
|
||
try:
|
||
log_ui.debug("[清空筛选]")
|
||
|
||
# 尝试点击清空/重置按钮
|
||
clear_btn = self.find(self.SELECTORS["clear_filter_button"])
|
||
if clear_btn.is_visible():
|
||
clear_btn.click()
|
||
self.wait_for_table_load()
|
||
log_ui.debug("[清空筛选成功] 通过按钮")
|
||
return True
|
||
|
||
# 如果没有清空按钮,尝试分别清除每个筛选器
|
||
# 清除状态筛选
|
||
status_locator = self.find(self.SELECTORS["status_filter"])
|
||
if status_locator.is_visible():
|
||
status_locator.click()
|
||
self.wait(500)
|
||
# 选择"全部"或清除选择
|
||
all_item = self.page.locator(".ant-select-dropdown .ant-select-item:has-text('全部')")
|
||
if all_item.is_visible():
|
||
all_item.click()
|
||
log_ui.debug("[清空状态筛选]")
|
||
else:
|
||
# 点击外部关闭下拉菜单
|
||
self.page.keyboard.press("Escape")
|
||
|
||
# 清除工作流筛选
|
||
workflow_locator = self.find(self.SELECTORS["workflow_filter"])
|
||
if workflow_locator.is_visible():
|
||
workflow_locator.click()
|
||
self.wait(500)
|
||
# 选择"全部"或清除选择
|
||
all_item = self.page.locator(".ant-select-dropdown .ant-select-item:has-text('全部')")
|
||
if all_item.is_visible():
|
||
all_item.click()
|
||
log_ui.debug("[清空工作流筛选]")
|
||
else:
|
||
# 点击外部关闭下拉菜单
|
||
self.page.keyboard.press("Escape")
|
||
|
||
# 触发重新加载
|
||
self.wait_for_table_load()
|
||
log_ui.debug("[清空筛选完成]")
|
||
return True
|
||
except Exception as e:
|
||
log_ui.error(f"[清空筛选异常]: {str(e)}")
|
||
return False
|
||
|
||
# ==================== 排序功能 ====================
|
||
|
||
def sort_by_column(self, column_name: str, ascending: bool = True) -> bool:
|
||
"""按列排序
|
||
|
||
Args:
|
||
column_name: 列名(显示文本)
|
||
ascending: 是否升序(True: 升序, False: 降序)
|
||
|
||
Returns:
|
||
bool: 是否成功排序
|
||
"""
|
||
try:
|
||
log_ui.debug(f"[排序] 列: '{column_name}', 升序: {ascending}")
|
||
|
||
# 查找包含指定列名的表头
|
||
headers = self.get_table_headers()
|
||
if not headers:
|
||
log_ui.debug("[排序失败] 未找到表头")
|
||
return False
|
||
|
||
# 找到列索引
|
||
column_index = None
|
||
for i, header in enumerate(headers):
|
||
if column_name in header:
|
||
column_index = i + 1 # 转换为1-based索引
|
||
break
|
||
|
||
if not column_index:
|
||
log_ui.debug(f"[排序失败] 未找到列: '{column_name}'")
|
||
return False
|
||
|
||
# 查找该列的可排序元素
|
||
sortable_header = self.page.locator(
|
||
f".ant-table-thead th:nth-child({column_index}) .ant-table-column-sorter"
|
||
)
|
||
|
||
if sortable_header.is_visible():
|
||
# 获取当前排序状态
|
||
current_sort = sortable_header.get_attribute("aria-label")
|
||
|
||
if not current_sort:
|
||
# 如果当前无排序,点击一次设置排序
|
||
sortable_header.click()
|
||
self.wait_for_table_load()
|
||
log_ui.debug(f"[排序设置] 列: '{column_name}'")
|
||
return True
|
||
|
||
# 如果当前已有排序,检查是否需要切换
|
||
# aria-label 可能包含 "sort", "ascend", "descend"
|
||
if (ascending and "descend" in current_sort) or (not ascending and "ascend" in current_sort):
|
||
# 点击切换排序方向
|
||
sortable_header.click()
|
||
self.wait_for_table_load()
|
||
|
||
log_ui.debug(f"[排序成功] 列: '{column_name}', 升序: {ascending}")
|
||
return True
|
||
else:
|
||
log_ui.debug(f"[排序失败] 列 '{column_name}' 不可排序")
|
||
return False
|
||
except Exception as e:
|
||
log_ui.error(f"[排序异常] 列 '{column_name}': {str(e)}")
|
||
return False
|
||
|
||
# ==================== 刷新功能 ====================
|
||
|
||
def refresh_list(self) -> bool:
|
||
"""刷新任务列表
|
||
|
||
Returns:
|
||
bool: 是否成功刷新
|
||
"""
|
||
try:
|
||
log_ui.debug("[刷新列表]")
|
||
|
||
# 查找刷新按钮
|
||
refresh_btn = self.find(self.SELECTORS["refresh_button"])
|
||
if refresh_btn.is_visible():
|
||
refresh_btn.click()
|
||
self.wait_for_table_load()
|
||
log_ui.debug("[刷新列表成功] 通过刷新按钮")
|
||
return True
|
||
|
||
# 如果找不到特定刷新按钮,使用页面刷新
|
||
self.reload()
|
||
self.wait_for_table_load()
|
||
log_ui.debug("[刷新列表成功] 通过页面刷新")
|
||
return True
|
||
except Exception as e:
|
||
log_ui.error(f"[刷新列表异常]: {str(e)}")
|
||
return False
|
||
|
||
# ==================== 批量操作 ====================
|
||
|
||
def select_all_tasks(self) -> bool:
|
||
"""全选任务
|
||
|
||
Returns:
|
||
bool: 是否成功全选
|
||
"""
|
||
try:
|
||
log_ui.debug("[全选任务]")
|
||
|
||
# 查找全选复选框
|
||
select_all = self.find(self.SELECTORS["select_all_checkbox"])
|
||
if select_all.is_visible():
|
||
# 检查是否已经选中
|
||
is_checked = select_all.locator("input").is_checked()
|
||
if not is_checked:
|
||
select_all.click()
|
||
log_ui.debug("[全选任务成功]")
|
||
else:
|
||
log_ui.debug("[全选任务] 已处于全选状态")
|
||
return True
|
||
else:
|
||
log_ui.debug("[全选任务失败] 未找到全选复选框")
|
||
return False
|
||
except Exception as e:
|
||
log_ui.error(f"[全选任务异常]: {str(e)}")
|
||
return False
|
||
|
||
def select_task(self, task_name: str) -> bool:
|
||
"""选择单个任务
|
||
|
||
Args:
|
||
task_name: 任务名称
|
||
|
||
Returns:
|
||
bool: 是否成功选择
|
||
"""
|
||
try:
|
||
log_ui.debug(f"[选择任务] 任务: '{task_name}'")
|
||
|
||
row = self.get_task_by_name(task_name)
|
||
if row:
|
||
# 查找任务行中的复选框
|
||
checkbox = row.locator(".ant-checkbox-wrapper")
|
||
if checkbox.is_visible():
|
||
# 检查是否已经选中
|
||
is_checked = checkbox.locator("input").is_checked()
|
||
if not is_checked:
|
||
checkbox.click()
|
||
log_ui.debug(f"[选择任务成功] 任务: '{task_name}'")
|
||
else:
|
||
log_ui.debug(f"[选择任务] 任务 '{task_name}' 已选中")
|
||
return True
|
||
else:
|
||
log_ui.debug(f"[选择任务失败] 任务 '{task_name}' 没有复选框")
|
||
return False
|
||
else:
|
||
log_ui.debug(f"[选择任务失败] 未找到任务: '{task_name}'")
|
||
return False
|
||
except Exception as e:
|
||
log_ui.error(f"[选择任务异常] 任务 '{task_name}': {str(e)}")
|
||
return False
|
||
|
||
def batch_delete(self) -> bool:
|
||
"""批量删除选中任务
|
||
|
||
Returns:
|
||
bool: 是否成功触发批量删除
|
||
"""
|
||
try:
|
||
log_ui.debug("[批量删除]")
|
||
|
||
# 检查是否有选中的任务
|
||
has_selected = self.page.locator(f"{self.SELECTORS['task_checkbox']} input:checked").count() > 0
|
||
if not has_selected:
|
||
log_ui.debug("[批量删除失败] 没有选中的任务")
|
||
return False
|
||
|
||
# 打开批量操作菜单
|
||
batch_menu = self.find(self.SELECTORS["batch_actions"])
|
||
if batch_menu.is_visible():
|
||
batch_menu.click()
|
||
self.wait(500) # 等待菜单打开
|
||
else:
|
||
log_ui.debug("[批量删除失败] 未找到批量操作菜单")
|
||
return False
|
||
|
||
# 选择删除选项
|
||
delete_option = self.page.locator(self.SELECTORS["batch_delete"])
|
||
if delete_option.is_visible():
|
||
delete_option.click()
|
||
log_ui.debug("[批量删除触发成功]")
|
||
|
||
# 等待确认对话框
|
||
self.page.wait_for_selector(".ant-modal", timeout=5000)
|
||
return True
|
||
else:
|
||
log_ui.debug("[批量删除失败] 未找到删除选项")
|
||
return False
|
||
except Exception as e:
|
||
log_ui.error(f"[批量删除异常]: {str(e)}")
|
||
return False
|
||
|
||
def batch_stop(self) -> bool:
|
||
"""批量停止选中任务
|
||
|
||
Returns:
|
||
bool: 是否成功触发批量停止
|
||
"""
|
||
try:
|
||
log_ui.debug("[批量停止]")
|
||
|
||
# 检查是否有选中的任务
|
||
has_selected = self.page.locator(f"{self.SELECTORS['task_checkbox']} input:checked").count() > 0
|
||
if not has_selected:
|
||
log_ui.debug("[批量停止失败] 没有选中的任务")
|
||
return False
|
||
|
||
# 打开批量操作菜单
|
||
batch_menu = self.find(self.SELECTORS["batch_actions"])
|
||
if batch_menu.is_visible():
|
||
batch_menu.click()
|
||
self.wait(500) # 等待菜单打开
|
||
else:
|
||
log_ui.debug("[批量停止失败] 未找到批量操作菜单")
|
||
return False
|
||
|
||
# 选择停止选项
|
||
stop_option = self.page.locator(self.SELECTORS["batch_stop"])
|
||
if stop_option.is_visible():
|
||
stop_option.click()
|
||
log_ui.debug("[批量停止触发成功]")
|
||
|
||
# 等待确认对话框或加载
|
||
self.wait(1000)
|
||
return True
|
||
else:
|
||
log_ui.debug("[批量停止失败] 未找到停止选项")
|
||
return False
|
||
except Exception as e:
|
||
log_ui.error(f"[批量停止异常]: {str(e)}")
|
||
return False
|
||
|
||
# ==================== 其他辅助方法 ====================
|
||
|
||
def get_task_count_by_status(self, status: str) -> int:
|
||
"""获取指定状态的任务数量
|
||
|
||
Args:
|
||
status: 状态值
|
||
|
||
Returns:
|
||
int: 任务数量
|
||
"""
|
||
try:
|
||
log_ui.debug(f"[获取状态数量] 状态: '{status}'")
|
||
|
||
count = 0
|
||
rows = self.page.locator(self.SELECTORS["task_table_rows"]).all()
|
||
for row in rows:
|
||
try:
|
||
status_text = row.locator(self.SELECTORS["task_status_column"]).inner_text()
|
||
if status in status_text:
|
||
count += 1
|
||
except Exception:
|
||
continue
|
||
|
||
log_ui.debug(f"[获取状态数量完成] 状态 '{status}': {count} 个")
|
||
return count
|
||
except Exception as e:
|
||
log_ui.error(f"[获取状态数量异常] 状态 '{status}': {str(e)}")
|
||
return 0
|
||
|
||
def wait_for_task_status(self, task_name: str, status: str, timeout: int = 60000) -> bool:
|
||
"""等待任务达到指定状态
|
||
|
||
Args:
|
||
task_name: 任务名称
|
||
status: 目标状态
|
||
timeout: 超时时间(毫秒)
|
||
|
||
Returns:
|
||
bool: 是否在超时前达到目标状态
|
||
"""
|
||
try:
|
||
log_ui.debug(f"[等待任务状态] 任务: '{task_name}', 目标状态: '{status}', 超时: {timeout}ms")
|
||
|
||
def check_status():
|
||
current_status = self.get_task_status(task_name)
|
||
return current_status is not None and status in current_status
|
||
|
||
result = self.wait_until(check_status, timeout=timeout)
|
||
|
||
if result:
|
||
log_ui.debug(f"[等待任务状态成功] 任务 '{task_name}' 达到状态 '{status}'")
|
||
else:
|
||
current_status = self.get_task_status(task_name)
|
||
log_ui.debug(f"[等待任务状态超时] 任务 '{task_name}' 当前状态: {current_status}, 目标状态: '{status}'")
|
||
|
||
return result
|
||
except Exception as e:
|
||
log_ui.error(f"[等待任务状态异常] 任务 '{task_name}': {str(e)}")
|
||
return False
|
||
|
||
def get_visible_columns(self) -> list[str]:
|
||
"""获取可见的列名
|
||
|
||
Returns:
|
||
list[str]: 列名列表
|
||
"""
|
||
try:
|
||
log_ui.debug("[获取可见列名]")
|
||
|
||
# 获取所有表头单元格的文本
|
||
headers = []
|
||
header_elements = self.page.locator(self.SELECTORS["task_table_headers"]).all()
|
||
|
||
for header in header_elements:
|
||
try:
|
||
if header.is_visible():
|
||
text = header.inner_text().strip()
|
||
if text:
|
||
headers.append(text)
|
||
except Exception:
|
||
continue
|
||
|
||
log_ui.debug(f"[获取可见列名完成] 列数: {len(headers)}")
|
||
return headers
|
||
except Exception as e:
|
||
log_ui.error(f"[获取可见列名异常]: {str(e)}")
|
||
return []
|
||
|
||
|
||
class WorkflowSelectionPage(BasePage):
|
||
"""数据生成 - 工作流选择/任务创建页面"""
|
||
|
||
SELECTORS = {
|
||
# 创建任务表单
|
||
"task_name_input": "input[placeholder*='任务名称']",
|
||
"workflow_select": ".ant-select:has-text('选择工作流')",
|
||
"instance_count_input": "input[type='number']",
|
||
"generate_count_input": "input[placeholder*='生成数量']",
|
||
"output_location_input": "input[placeholder*='输出位置']",
|
||
"execute_button": "button:has-text('执行')",
|
||
"reset_button": "button:has-text('重置')",
|
||
"cancel_button": "button:has-text('取消')",
|
||
"back_button": "button:has-text('返回')",
|
||
# 工作流卡片
|
||
"workflow_card": ".workflow-card",
|
||
"workflow_title": "h5",
|
||
"workflow_description": ".workflow-card .workflow-description",
|
||
"workflow_preview_button": "button:has-text('预览')",
|
||
# 搜索筛选相关
|
||
"search_input": "input[placeholder*='搜索工作流']",
|
||
"filter_dropdown": ".ant-select:has-text('筛选类型')",
|
||
"filter_type_all": ".ant-select-dropdown li:has-text('全部')",
|
||
"filter_type_system": ".ant-select-dropdown li:has-text('系统')",
|
||
"filter_type_custom": ".ant-select-dropdown li:has-text('自定义')",
|
||
"clear_search_button": "button:has-text('清空')",
|
||
# 高级设置相关
|
||
"advanced_settings_button": "button:has-text('高级设置')",
|
||
"advanced_settings_panel": ".ant-collapse-content-active",
|
||
"instance_count_advanced": "input[placeholder*='实例数量']",
|
||
"generate_count_advanced": "input[placeholder*='生成数量']",
|
||
"output_location_advanced": "input[placeholder*='输出位置']",
|
||
# 错误提示
|
||
"error_messages": ".ant-form-item-explain-error",
|
||
"form_validation_error": ".ant-form-item-has-error",
|
||
}
|
||
|
||
def __init__(self, page: Page):
|
||
super().__init__(page)
|
||
|
||
def fill_task_form(self, task_name: str, workflow: str = None):
|
||
"""填写任务创建表单"""
|
||
self.page.locator(self.SELECTORS["task_name_input"]).fill(task_name)
|
||
if workflow:
|
||
self.page.locator(self.SELECTORS["workflow_select"]).click()
|
||
self.page.locator(f".ant-select-dropdown li:has-text('{workflow}')").click()
|
||
|
||
# ==================== 1. 搜索和筛选 ====================
|
||
|
||
def search_workflows(self, keyword: str) -> None:
|
||
"""搜索工作流"""
|
||
try:
|
||
log_ui.debug(f"[搜索工作流] 关键词: {keyword}")
|
||
search_input = self.page.locator(self.SELECTORS["search_input"])
|
||
if search_input.is_visible():
|
||
search_input.fill(keyword)
|
||
self.page.keyboard.press("Enter")
|
||
self.wait_for_page_ready()
|
||
log_ui.debug(f"[搜索工作流] 搜索完成,等待结果")
|
||
else:
|
||
log_ui.warning("[搜索工作流] 搜索框不可见")
|
||
except Exception as e:
|
||
log_ui.error(f"[搜索工作流] 异常: {e}")
|
||
raise
|
||
|
||
def filter_workflows(self, filter_type: str) -> None:
|
||
"""筛选工作流"""
|
||
try:
|
||
log_ui.debug(f"[筛选工作流] 类型: {filter_type}")
|
||
self.click(self.SELECTORS["filter_dropdown"])
|
||
self.page.wait_for_timeout(500) # 等待下拉菜单展开
|
||
|
||
# 根据筛选类型选择对应的选项
|
||
if filter_type.lower() == "all" or filter_type == "全部":
|
||
self.click(self.SELECTORS["filter_type_all"])
|
||
elif filter_type.lower() == "system" or filter_type == "系统":
|
||
self.click(self.SELECTORS["filter_type_system"])
|
||
elif filter_type.lower() == "custom" or filter_type == "自定义":
|
||
self.click(self.SELECTORS["filter_type_custom"])
|
||
else:
|
||
# 尝试直接点击包含该文本的选项
|
||
self.click(f".ant-select-dropdown li:has-text('{filter_type}')")
|
||
|
||
self.wait_for_page_ready()
|
||
log_ui.debug(f"[筛选工作流] 筛选完成")
|
||
except Exception as e:
|
||
log_ui.error(f"[筛选工作流] 异常: {e}")
|
||
raise
|
||
|
||
def clear_workflow_search(self) -> None:
|
||
"""清空工作流搜索"""
|
||
try:
|
||
log_ui.debug("[清空工作流搜索]")
|
||
# 清空搜索框
|
||
search_input = self.page.locator(self.SELECTORS["search_input"])
|
||
if search_input.is_visible():
|
||
search_input.clear()
|
||
|
||
# 如果有关闭按钮,点击它
|
||
if self.is_visible(self.SELECTORS["clear_search_button"]):
|
||
self.click(self.SELECTORS["clear_search_button"])
|
||
|
||
self.page.keyboard.press("Enter")
|
||
self.wait_for_page_ready()
|
||
log_ui.debug("[清空工作流搜索] 完成")
|
||
except Exception as e:
|
||
log_ui.error(f"[清空工作流搜索] 异常: {e}")
|
||
raise
|
||
|
||
# ==================== 2. 工作流详情 ====================
|
||
|
||
def preview_workflow(self, workflow_name: str) -> bool:
|
||
"""预览工作流详情"""
|
||
try:
|
||
log_ui.debug(f"[预览工作流] 名称: {workflow_name}")
|
||
cards = self.page.locator(self.SELECTORS["workflow_card"]).all()
|
||
for card in cards:
|
||
try:
|
||
title = card.locator(self.SELECTORS["workflow_title"]).inner_text()
|
||
if workflow_name in title:
|
||
# 查找预览按钮并点击
|
||
preview_btn = card.locator(self.SELECTORS["workflow_preview_button"])
|
||
if preview_btn.is_visible():
|
||
preview_btn.click()
|
||
# 等待预览弹窗或详情页出现
|
||
self.page.wait_for_timeout(1000)
|
||
log_ui.debug(f"[预览工作流] 成功: {workflow_name}")
|
||
return True
|
||
except Exception:
|
||
continue
|
||
|
||
log_ui.warning(f"[预览工作流] 未找到工作流或预览按钮: {workflow_name}")
|
||
return False
|
||
except Exception as e:
|
||
log_ui.error(f"[预览工作流] 异常: {e}")
|
||
return False
|
||
|
||
def get_workflow_info(self, workflow_name: str) -> dict:
|
||
"""获取工作流信息"""
|
||
try:
|
||
log_ui.debug(f"[获取工作流信息] 名称: {workflow_name}")
|
||
cards = self.page.locator(self.SELECTORS["workflow_card"]).all()
|
||
for card in cards:
|
||
try:
|
||
title = card.locator(self.SELECTORS["workflow_title"]).inner_text()
|
||
if workflow_name in title:
|
||
info = {
|
||
"name": title.strip(),
|
||
"is_selected": "selected" in (card.get_attribute("class") or ""),
|
||
}
|
||
|
||
# 尝试获取描述
|
||
try:
|
||
description = card.locator(self.SELECTORS["workflow_description"]).inner_text()
|
||
info["description"] = description.strip()
|
||
except Exception:
|
||
info["description"] = ""
|
||
|
||
# 尝试获取其他属性
|
||
try:
|
||
# 工作流类型标签
|
||
type_elem = card.locator(".workflow-type").first
|
||
if type_elem.is_visible():
|
||
info["type"] = type_elem.inner_text()
|
||
except Exception:
|
||
pass
|
||
|
||
log_ui.debug(f"[获取工作流信息] 成功: {info}")
|
||
return info
|
||
except Exception:
|
||
continue
|
||
|
||
log_ui.warning(f"[获取工作流信息] 未找到工作流: {workflow_name}")
|
||
return {}
|
||
except Exception as e:
|
||
log_ui.error(f"[获取工作流信息] 异常: {e}")
|
||
return {}
|
||
|
||
# ==================== 3. 取消创建 ====================
|
||
|
||
def cancel_create(self) -> None:
|
||
"""取消创建任务,返回列表页"""
|
||
try:
|
||
log_ui.debug("[取消创建任务]")
|
||
# 尝试点击取消按钮
|
||
if self.click_if_visible(self.SELECTORS["cancel_button"]):
|
||
self.wait_for_page_ready()
|
||
log_ui.debug("[取消创建任务] 通过取消按钮完成")
|
||
return
|
||
|
||
# 如果没有取消按钮,尝试返回按钮
|
||
if self.click_if_visible(self.SELECTORS["back_button"]):
|
||
self.wait_for_page_ready()
|
||
log_ui.debug("[取消创建任务] 通过返回按钮完成")
|
||
return
|
||
|
||
# 如果都没有,按 Esc 键
|
||
self.page.keyboard.press("Escape")
|
||
self.wait_for_page_ready()
|
||
log_ui.debug("[取消创建任务] 通过 Esc 键完成")
|
||
except Exception as e:
|
||
log_ui.error(f"[取消创建任务] 异常: {e}")
|
||
raise
|
||
|
||
# ==================== 4. 表单验证 ====================
|
||
|
||
def validate_form(self) -> list[str]:
|
||
"""验证表单,返回错误信息列表"""
|
||
try:
|
||
log_ui.debug("[验证表单]")
|
||
error_messages = []
|
||
|
||
# 检查表单错误提示
|
||
error_elements = self.page.locator(self.SELECTORS["error_messages"])
|
||
if error_elements.count() > 0:
|
||
for i in range(error_elements.count()):
|
||
try:
|
||
error_text = error_elements.nth(i).inner_text()
|
||
if error_text and error_text.strip():
|
||
error_messages.append(error_text.strip())
|
||
except Exception:
|
||
continue
|
||
|
||
# 检查表单项是否有错误状态
|
||
error_items = self.page.locator(self.SELECTORS["form_validation_error"])
|
||
if error_items.count() > 0 and len(error_messages) == 0:
|
||
error_messages.append("表单包含验证错误")
|
||
|
||
log_ui.debug(f"[验证表单] 发现 {len(error_messages)} 个错误")
|
||
return error_messages
|
||
except Exception as e:
|
||
log_ui.error(f"[验证表单] 异常: {e}")
|
||
return ["表单验证过程中出现异常"]
|
||
|
||
def is_form_valid(self) -> bool:
|
||
"""检查表单是否有效"""
|
||
try:
|
||
errors = self.validate_form()
|
||
return len(errors) == 0
|
||
except Exception as e:
|
||
log_ui.error(f"[检查表单是否有效] 异常: {e}")
|
||
return False
|
||
|
||
# ==================== 5. 高级参数 ====================
|
||
|
||
def expand_advanced_settings(self) -> None:
|
||
"""展开高级设置"""
|
||
try:
|
||
log_ui.debug("[展开高级设置]")
|
||
if self.is_visible(self.SELECTORS["advanced_settings_panel"]):
|
||
log_ui.debug("[展开高级设置] 已展开")
|
||
return
|
||
|
||
self.click(self.SELECTORS["advanced_settings_button"])
|
||
# 等待高级设置面板展开
|
||
self.page.wait_for_selector(self.SELECTORS["advanced_settings_panel"], timeout=5000)
|
||
log_ui.debug("[展开高级设置] 完成")
|
||
except Exception as e:
|
||
log_ui.error(f"[展开高级设置] 异常: {e}")
|
||
raise
|
||
|
||
def set_instance_count(self, count: int) -> None:
|
||
"""设置实例数量"""
|
||
try:
|
||
log_ui.debug(f"[设置实例数量] 数量: {count}")
|
||
# 先尝试高级设置中的实例数量输入框
|
||
input_selector = self.SELECTORS["instance_count_advanced"]
|
||
input_element = self.page.locator(input_selector)
|
||
|
||
# 如果高级设置中的输入框不可见,尝试使用基础输入框
|
||
if not input_element.is_visible():
|
||
input_selector = self.SELECTORS["instance_count_input"]
|
||
input_element = self.page.locator(input_selector)
|
||
|
||
if input_element.is_visible():
|
||
input_element.fill(str(count))
|
||
log_ui.debug(f"[设置实例数量] 完成")
|
||
else:
|
||
log_ui.warning("[设置实例数量] 实例数量输入框不可见")
|
||
except Exception as e:
|
||
log_ui.error(f"[设置实例数量] 异常: {e}")
|
||
raise
|
||
|
||
def set_generate_count(self, count: int) -> None:
|
||
"""设置生成数量"""
|
||
try:
|
||
log_ui.debug(f"[设置生成数量] 数量: {count}")
|
||
# 先尝试高级设置中的生成数量输入框
|
||
input_selector = self.SELECTORS["generate_count_advanced"]
|
||
input_element = self.page.locator(input_selector)
|
||
|
||
# 如果高级设置中的输入框不可见,尝试使用基础输入框
|
||
if not input_element.is_visible():
|
||
input_selector = self.SELECTORS["generate_count_input"]
|
||
input_element = self.page.locator(input_selector)
|
||
|
||
if input_element.is_visible():
|
||
input_element.fill(str(count))
|
||
log_ui.debug(f"[设置生成数量] 完成")
|
||
else:
|
||
log_ui.warning("[设置生成数量] 生成数量输入框不可见")
|
||
except Exception as e:
|
||
log_ui.error(f"[设置生成数量] 异常: {e}")
|
||
raise
|
||
|
||
def set_output_location(self, path: str) -> None:
|
||
"""设置输出位置"""
|
||
try:
|
||
log_ui.debug(f"[设置输出位置] 路径: {path}")
|
||
# 先尝试高级设置中的输出位置输入框
|
||
input_selector = self.SELECTORS["output_location_advanced"]
|
||
input_element = self.page.locator(input_selector)
|
||
|
||
# 如果高级设置中的输入框不可见,尝试使用基础输入框
|
||
if not input_element.is_visible():
|
||
input_selector = self.SELECTORS["output_location_input"]
|
||
input_element = self.page.locator(input_selector)
|
||
|
||
if input_element.is_visible():
|
||
input_element.fill(path)
|
||
log_ui.debug(f"[设置输出位置] 完成")
|
||
else:
|
||
log_ui.warning("[设置输出位置] 输出位置输入框不可见")
|
||
except Exception as e:
|
||
log_ui.error(f"[设置输出位置] 异常: {e}")
|
||
raise
|
||
|
||
def click_execute(self):
|
||
"""点击执行按钮"""
|
||
self.click(self.SELECTORS["execute_button"])
|
||
self.page.wait_for_load_state("networkidle")
|
||
|
||
def click_reset(self):
|
||
"""点击重置按钮"""
|
||
self.click(self.SELECTORS["reset_button"])
|
||
|
||
def select_workflow_card(self, name: str) -> bool:
|
||
"""选择指定名称的工作流卡片"""
|
||
cards = self.page.locator(self.SELECTORS["workflow_card"]).all()
|
||
for card in cards:
|
||
try:
|
||
title = card.locator(self.SELECTORS["workflow_title"]).inner_text()
|
||
if name in title:
|
||
card.click()
|
||
return True
|
||
except Exception:
|
||
pass
|
||
return False
|
||
|
||
def get_workflow_cards(self) -> list[str]:
|
||
"""获取所有工作流卡片名称"""
|
||
cards = self.page.locator(self.SELECTORS["workflow_card"]).all()
|
||
names = []
|
||
for card in cards:
|
||
try:
|
||
title = card.locator(self.SELECTORS["workflow_title"]).inner_text()
|
||
names.append(title)
|
||
except Exception:
|
||
pass
|
||
return names
|
||
|
||
def is_workflow_selected(self, name: str) -> bool:
|
||
"""检查工作流是否已选中"""
|
||
cards = self.page.locator(self.SELECTORS["workflow_card"]).all()
|
||
for card in cards:
|
||
try:
|
||
title = card.locator(self.SELECTORS["workflow_title"]).inner_text()
|
||
if name in title:
|
||
return "selected" in (card.get_attribute("class") or "")
|
||
except Exception:
|
||
pass
|
||
return False
|
||
|
||
|
||
# 向后兼容:保留旧名称作为 TaskListPage 的别名
|
||
DataGenerationPage = TaskListPage
|
||
|
||
|
||
class TaskDetailPage(BasePage):
|
||
"""数据生成 - 任务详情页面"""
|
||
|
||
url_template = "https://cloud-fat.d-robotics.cc/d-cloud/data-create/taskdetail/{task_id}"
|
||
|
||
SELECTORS = {
|
||
# Tab - 实际页面只有"详细信息"和"输出结果"两个Tab
|
||
"output_tab": ".ant-tabs-tab:has-text('输出结果')",
|
||
"info_tab": ".ant-tabs-tab:has-text('详细信息')", # 注意:页面显示的是"详细信息",不是"任务信息"
|
||
"active_tab": ".ant-tabs-tab-active",
|
||
"tab_content": ".ant-tabs-content",
|
||
"output_tab_content": ".ant-tabs-tabpane-active",
|
||
|
||
# 输出结果
|
||
"output_gallery": ".output-gallery",
|
||
"output_image": ".output-image",
|
||
"output_file_list": ".output-file-list",
|
||
"output_file_item": ".output-file-item",
|
||
"download_button": "button:has-text('下载')",
|
||
"export_all_button": "button:has-text('导出所有')",
|
||
"image_preview": ".image-preview",
|
||
|
||
# 详细信息 - 使用表格结构
|
||
"info_section": ".task-info-section",
|
||
"info_table": "table",
|
||
"info_item": ".info-item",
|
||
"info_label": ".info-label",
|
||
"info_value": ".info-value",
|
||
"metrics_section": ".metrics-section",
|
||
"metric_card": ".metric-card",
|
||
|
||
# 任务操作
|
||
"stop_button": "button:has-text('停止')",
|
||
"restart_button": "button:has-text('重启')",
|
||
"clone_button": "button:has-text('克隆')",
|
||
"score_button": "button:has-text('触发评测')",
|
||
"action_button_group": ".action-buttons",
|
||
|
||
# 状态指示器
|
||
"task_status": ".task-status",
|
||
"status_running": ".status-running",
|
||
"status_completed": ".status-completed",
|
||
"status_failed": ".status-failed",
|
||
"progress_bar": ".progress-bar",
|
||
|
||
# 页面标题和头部
|
||
"page_title": "h1, h2:has-text('任务详情')",
|
||
"back_button": "button:has-text('返回'), a:has-text('返回')",
|
||
|
||
# 模态框和确认对话框
|
||
"confirm_modal": ".ant-modal",
|
||
"confirm_ok": "button:has-text('确定'), button:has-text('OK')",
|
||
"confirm_cancel": "button:has-text('取消'), button:has-text('Cancel')",
|
||
}
|
||
|
||
def __init__(self, page: Page, task_id: str = None):
|
||
super().__init__(page)
|
||
self.task_id = task_id
|
||
if task_id:
|
||
self.url = self.url_template.format(task_id=task_id)
|
||
else:
|
||
self.url = None
|
||
|
||
def navigate_to_task_detail(self, task_id: str):
|
||
"""导航到指定任务的详情页"""
|
||
self.task_id = task_id
|
||
self.url = self.url_template.format(task_id=task_id)
|
||
self.navigate(self.url)
|
||
|
||
# ==================== Tab 切换 ====================
|
||
|
||
def switch_to_tab(self, tab_name: str) -> None:
|
||
"""切换Tab页(输出结果/详细信息)
|
||
|
||
注意:页面只有"详细信息"和"输出结果"两个Tab
|
||
"""
|
||
tab_selector = None
|
||
if tab_name == "输出结果":
|
||
tab_selector = self.SELECTORS["output_tab"]
|
||
elif tab_name in ("详细信息", "任务信息"): # 兼容旧的"任务信息"名称
|
||
tab_selector = self.SELECTORS["info_tab"]
|
||
else:
|
||
raise ValueError(f"不支持的Tab名称: {tab_name}")
|
||
|
||
if tab_selector:
|
||
self.click(tab_selector)
|
||
self.wait_for_element(self.SELECTORS["tab_content"])
|
||
|
||
def get_current_tab(self) -> str:
|
||
"""获取当前激活的Tab"""
|
||
active_tab = self.page.locator(self.SELECTORS["active_tab"])
|
||
if active_tab.is_visible():
|
||
return active_tab.inner_text()
|
||
return ""
|
||
|
||
# ==================== 输出结果 ====================
|
||
|
||
def get_output_images(self) -> list[str]:
|
||
"""获取输出图片列表"""
|
||
images = []
|
||
image_locators = self.page.locator(self.SELECTORS["output_image"]).all()
|
||
for img in image_locators:
|
||
try:
|
||
# 获取图片名称或alt属性
|
||
alt_text = img.get_attribute("alt") or img.get_attribute("title") or ""
|
||
images.append(alt_text)
|
||
except Exception:
|
||
pass
|
||
return images
|
||
|
||
def get_output_files(self) -> list[str]:
|
||
"""获取输出文件列表"""
|
||
files = []
|
||
file_locators = self.page.locator(self.SELECTORS["output_file_item"]).all()
|
||
for file_item in file_locators:
|
||
try:
|
||
file_name = file_item.inner_text()
|
||
if file_name:
|
||
files.append(file_name.strip())
|
||
except Exception:
|
||
pass
|
||
return files
|
||
|
||
def download_output(self, file_name: str) -> None:
|
||
"""下载输出文件"""
|
||
# 查找包含指定文件名的下载按钮
|
||
file_item = self.page.locator(f"{self.SELECTORS['output_file_item']}:has-text('{file_name}')")
|
||
if file_item.is_visible():
|
||
# 查找同一行或相邻的下载按钮
|
||
download_btn = file_item.locator(self.SELECTORS["download_button"])
|
||
if download_btn.is_visible():
|
||
with self.page.expect_download() as download_info:
|
||
download_btn.click()
|
||
download = download_info.value
|
||
# 保存到默认下载目录或自定义路径
|
||
download.save_as(f"downloads/{download.suggested_filename}")
|
||
|
||
def export_all_outputs(self) -> None:
|
||
"""导出所有输出"""
|
||
if self.click_if_visible(self.SELECTORS["export_all_button"]):
|
||
# 等待导出操作完成
|
||
self.wait_for_page_ready()
|
||
|
||
# ==================== 运行日志 ====================
|
||
|
||
def get_log_content(self) -> str:
|
||
"""获取日志内容"""
|
||
log_content = self.page.locator(self.SELECTORS["log_content"])
|
||
if log_content.is_visible():
|
||
return log_content.inner_text()
|
||
|
||
# 备选方案:文本区域
|
||
log_textarea = self.page.locator(self.SELECTORS["log_text_area"])
|
||
if log_textarea.is_visible():
|
||
return log_textarea.input_value()
|
||
|
||
return ""
|
||
|
||
def refresh_logs(self) -> None:
|
||
"""刷新日志"""
|
||
self.click_if_visible(self.SELECTORS["refresh_log_button"])
|
||
# 等待日志重新加载
|
||
self.wait_for_element(self.SELECTORS["log_content"])
|
||
|
||
def search_logs(self, keyword: str) -> list[str]:
|
||
"""搜索日志"""
|
||
# 输入搜索关键词
|
||
search_input = self.page.locator(self.SELECTORS["search_log_input"])
|
||
if search_input.is_visible():
|
||
search_input.fill(keyword)
|
||
search_input.press("Enter")
|
||
|
||
# 等待搜索结果
|
||
self.wait_for_element(self.SELECTORS["log_search_results"])
|
||
|
||
# 获取匹配的日志行
|
||
matching_lines = []
|
||
log_lines = self.page.locator(self.SELECTORS["log_line"]).all()
|
||
for line in log_lines:
|
||
try:
|
||
line_text = line.inner_text()
|
||
if keyword.lower() in line_text.lower():
|
||
matching_lines.append(line_text)
|
||
except Exception:
|
||
pass
|
||
return matching_lines
|
||
return []
|
||
|
||
# ==================== 任务信息 ====================
|
||
|
||
def get_task_info(self) -> dict:
|
||
"""获取任务基本信息"""
|
||
info_dict = {}
|
||
info_items = self.page.locator(self.SELECTORS["info_item"]).all()
|
||
|
||
for item in info_items:
|
||
try:
|
||
label = item.locator(self.SELECTORS["info_label"]).inner_text().strip()
|
||
value = item.locator(self.SELECTORS["info_value"]).inner_text().strip()
|
||
if label and value:
|
||
# 移除末尾冒号
|
||
label = label.rstrip("::")
|
||
info_dict[label] = value
|
||
except Exception:
|
||
pass
|
||
|
||
return info_dict
|
||
|
||
def get_task_metrics(self) -> dict:
|
||
"""获取任务指标(耗时、资源使用等)"""
|
||
metrics_dict = {}
|
||
metric_cards = self.page.locator(self.SELECTORS["metric_card"]).all()
|
||
|
||
for card in metric_cards:
|
||
try:
|
||
# 假设指标卡片有标题和数值
|
||
title = card.locator(".metric-title").inner_text().strip()
|
||
value = card.locator(".metric-value").inner_text().strip()
|
||
if title and value:
|
||
metrics_dict[title] = value
|
||
except Exception:
|
||
pass
|
||
|
||
return metrics_dict
|
||
|
||
# ==================== Pod管理 ====================
|
||
|
||
def get_pod_list(self) -> list[dict]:
|
||
"""获取Pod列表"""
|
||
pods = []
|
||
pod_rows = self.page.locator(self.SELECTORS["pod_row"]).all()
|
||
|
||
for row in pod_rows:
|
||
try:
|
||
name = row.locator(self.SELECTORS["pod_name"]).inner_text().strip()
|
||
status = row.locator(self.SELECTORS["pod_status"]).inner_text().strip()
|
||
pods.append({"name": name, "status": status})
|
||
except Exception:
|
||
pass
|
||
|
||
return pods
|
||
|
||
def get_pod_status(self, pod_name: str) -> str:
|
||
"""获取Pod状态"""
|
||
pods = self.get_pod_list()
|
||
for pod in pods:
|
||
if pod["name"] == pod_name:
|
||
return pod["status"]
|
||
return ""
|
||
|
||
def view_pod_logs(self, pod_name: str) -> str:
|
||
"""查看Pod日志"""
|
||
# 先导航到Pod管理tab
|
||
self.switch_to_tab("Pod管理")
|
||
|
||
# 找到指定Pod的查看日志按钮
|
||
pod_row = self.page.locator(f"{self.SELECTORS['pod_row']}:has-text('{pod_name}')")
|
||
if pod_row.is_visible():
|
||
view_logs_btn = pod_row.locator(self.SELECTORS["view_logs_button"])
|
||
if view_logs_btn.is_visible():
|
||
view_logs_btn.click()
|
||
|
||
# 等待日志窗口/模态框出现
|
||
log_window = self.page.locator(self.SELECTORS["log_content"])
|
||
if log_window.is_visible(timeout=5000):
|
||
return log_window.inner_text()
|
||
|
||
return ""
|
||
|
||
# ==================== 任务操作 ====================
|
||
|
||
def stop_task(self) -> bool:
|
||
"""停止任务"""
|
||
if self.click_if_visible(self.SELECTORS["stop_button"]):
|
||
# 确认对话框处理
|
||
if self.smart_wait(self.SELECTORS["confirm_modal"]):
|
||
self.click_if_visible(self.SELECTORS["confirm_ok"])
|
||
# 等待操作完成
|
||
self.wait_for_page_ready()
|
||
return True
|
||
return False
|
||
|
||
def restart_task(self) -> bool:
|
||
"""重启任务"""
|
||
if self.click_if_visible(self.SELECTORS["restart_button"]):
|
||
if self.smart_wait(self.SELECTORS["confirm_modal"]):
|
||
self.click_if_visible(self.SELECTORS["confirm_ok"])
|
||
self.wait_for_page_ready()
|
||
return True
|
||
return False
|
||
|
||
def clone_task(self) -> bool:
|
||
"""克隆任务"""
|
||
if self.click_if_visible(self.SELECTORS["clone_button"]):
|
||
# 克隆应该导航到任务创建页面
|
||
self.wait_for_page_ready()
|
||
return True
|
||
return False
|
||
|
||
def trigger_score(self) -> bool:
|
||
"""触发图片评测"""
|
||
if self.click_if_visible(self.SELECTORS["score_button"]):
|
||
if self.smart_wait(self.SELECTORS["confirm_modal"]):
|
||
self.click_if_visible(self.SELECTORS["confirm_ok"])
|
||
# 等待评测结果
|
||
self.wait_for_page_ready()
|
||
return True
|
||
return False
|
||
|
||
# ==================== 状态检查 ====================
|
||
|
||
def is_task_running(self) -> bool:
|
||
"""任务是否运行中"""
|
||
status_text = self._get_task_status_text()
|
||
return "运行中" in status_text or "running" in status_text.lower()
|
||
|
||
def is_task_completed(self) -> bool:
|
||
"""任务是否完成"""
|
||
status_text = self._get_task_status_text()
|
||
return "已完成" in status_text or "completed" in status_text.lower()
|
||
|
||
def is_task_failed(self) -> bool:
|
||
"""任务是否失败"""
|
||
status_text = self._get_task_status_text()
|
||
return "失败" in status_text or "failed" in status_text.lower()
|
||
|
||
def _get_task_status_text(self) -> str:
|
||
"""获取任务状态文本"""
|
||
status_element = self.page.locator(self.SELECTORS["task_status"])
|
||
if status_element.is_visible():
|
||
return status_element.inner_text().strip()
|
||
return ""
|
||
|
||
def get_progress(self) -> float:
|
||
"""获取任务进度(0-100)"""
|
||
progress_bar = self.page.locator(self.SELECTORS["progress_bar"])
|
||
if progress_bar.is_visible():
|
||
# 获取进度条样式或属性
|
||
width_attr = progress_bar.get_attribute("style") or ""
|
||
import re
|
||
match = re.search(r"width:\s*(\d+)%", width_attr)
|
||
if match:
|
||
return float(match.group(1))
|
||
return 0.0
|
||
|
||
# ==================== 通用页面操作 ====================
|
||
|
||
def go_back(self) -> None:
|
||
"""返回上一页"""
|
||
self.click_if_visible(self.SELECTORS["back_button"])
|
||
|
||
def wait_for_task_completion(self, timeout: int = 300000, interval: int = 5000) -> bool:
|
||
"""等待任务完成"""
|
||
def check_task_completed():
|
||
return self.is_task_completed() or self.is_task_failed()
|
||
|
||
return self.wait_until(check_task_completed, timeout=timeout, interval=interval)
|
||
|
||
def refresh_page(self) -> None:
|
||
"""刷新页面"""
|
||
self.reload()
|