TBC/tests/data_generation/data_generation_page.py

1460 lines
57 KiB
Python
Raw 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.

"""
数据生成模块Page Object
封装数据生成模块的UI元素和操作
拆分为 TaskListPage(任务列表)和 WorkflowSelectionPage(工作流选择/任务创建)
"""
from __future__ import annotations
import os
from playwright.sync_api import Page, Locator
from tests.base.base_page import BasePage
from tests.logger import log_ui
class TaskListPage(BasePage):
"""数据生成 - 任务列表页面"""
BASE_URL = os.getenv("DCLOUD_BASE_URL", "https://cloud-fat.d-robotics.cc")
url = f"{BASE_URL}/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):
"""数据生成 - 任务详情页面"""
BASE_URL = os.getenv("DCLOUD_BASE_URL", "https://cloud-fat.d-robotics.cc")
url_template = f"{BASE_URL}/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()