Files
agent-radar 1a3a4ccde1
Creator App Tests / PR Spam Gate (push) Skipped
Frontend Tests / PR Spam Gate (push) Skipped
NPM Format (website & console) / PR Spam Gate (push) Skipped
Pre-commit Checks / PR Spam Gate (push) Skipped
QwenPaw Creator Plugin Release / check-version (push) Canceled after 0s
QwenPaw Creator Plugin Release / upload-oss (push) Canceled after 0s
Tests / PR Spam Gate (push) Skipped
CodeQL / CodeQL (python) (push) Canceled after 0s
CodeQL / CodeQL (typescript) (push) Canceled after 0s
Creator App Tests / Creator Backend Tests (push) Canceled after 0s
Creator App Tests / Creator UI Build & Tests (push) Canceled after 0s
E2E Smoke Tests / Playwright UI Smoke (push) Canceled after 0s
Frontend Tests / Detect console changes (push) Canceled after 0s
NPM Format (website & console) / website format check (push) Canceled after 0s
NPM Format (website & console) / console format check (push) Canceled after 0s
Pre-commit Checks / Pre-commit (push) Canceled after 0s
QwenPaw Data Plugin Release / check-version (push) Canceled after 0s
Tests / Detect code changes (push) Canceled after 0s
Frontend Tests / Vitest Unit Tests (push) Canceled after 0s
Frontend Tests / Frontend Summary (push) Canceled after 0s
QwenPaw Data Plugin Release / upload-oss (push) Canceled after 0s
Tests / Maintainer Approval (push) Canceled after 0s
Tests / Unit Tests - py3.11 - macos-latest (push) Canceled after 0s
Tests / Unit Tests - py3.11 - ubuntu-latest (push) Canceled after 0s
Tests / Unit Tests - py3.13 - ubuntu-latest (push) Canceled after 0s
Tests / Unit Tests - py3.11 - windows-latest (push) Canceled after 0s
Tests / Contract Tests - py3.11 - macos-latest (push) Canceled after 0s
Tests / Contract Tests - py3.11 - ubuntu-latest (push) Canceled after 0s
Tests / Contract Tests - py3.13 - ubuntu-latest (push) Canceled after 0s
Tests / Contract Tests - py3.11 - windows-latest (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - macos-latest - p0 (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - macos-latest - p1 (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - macos-latest - p2 (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - ubuntu-latest - fallback (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - ubuntu-latest - p0 (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - ubuntu-latest - p1 (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - ubuntu-latest - p2 (push) Canceled after 0s
Tests / Integrated Tests - py3.13 - ubuntu-latest - p0 (push) Canceled after 0s
Tests / Integrated Tests - py3.13 - ubuntu-latest - p1 (push) Canceled after 0s
Tests / Integrated Tests - py3.13 - ubuntu-latest - p2 (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - windows-latest - p0 (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - windows-latest - p1 (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - windows-latest - p2 (push) Canceled after 0s
Tests / Coverage Report (push) Canceled after 0s
Tests / Test Summary (push) Canceled after 0s
源码快照 @ 2026-09-01 (source-only, 剔除非源码素材)
2026-09-01 20:01:50 +08:00

1500 lines
58 KiB
Python

# -*- coding: utf-8 -*-
"""
QwenPaw Chat page object.
Wraps all interactions on the Chat page and exposes business-level methods.
"""
from __future__ import annotations
import logging
import re
from typing import Optional, List, Tuple
from pathlib import Path
from playwright.sync_api import Page, Locator, expect, TimeoutError
from pages.base_page import BasePage
from config.settings import config
logger = logging.getLogger(__name__)
class ChatPage(BasePage):
"""
Chat page object.
Wraps all user interactions on the Chat page:
- Create new conversation
- Send messages
- File upload
- Session management
- Model switching
- Skill invocation
"""
PAGE_TITLE = "QwenPaw Console"
PAGE_URL = f"{config.base_url}/chat"
# ========== Selector definitions ==========
# Page components use the qwenpaw- CSS prefix
# Navigation and new chat (compatible with both spark-icon and anticon icon sets)
NEW_CHAT_BTN = 'button:has(.spark-icon-spark-newChat-fill), button:has(.anticon-plus), button:has([class*="newChat"])'
SESSION_LIST_BTN = 'button:has(.spark-icon-spark-history-line), button:has(.anticon-history), button:has([class*="history"])'
# Input area
CHAT_INPUT = (
'.qwenpaw-sender [role="textbox"][contenteditable="true"]:visible, '
"textarea.qwenpaw-sender-input:visible"
)
SEND_BTN = 'button.qwenpaw-sender-actions-btn.qwenpaw-btn-primary'
FILE_INPUT = 'input[type="file"]'
UPLOAD_WRAPPER = 'span.qwenpaw-upload-wrapper'
# Message area
USER_MESSAGE = '.qwenpaw-bubble.qwenpaw-bubble-end'
AI_MESSAGE = '.qwenpaw-bubble.qwenpaw-bubble-start'
MESSAGE_CONTAINER = '.qwenpaw-bubble.qwenpaw-bubble-start, .qwenpaw-bubble.qwenpaw-bubble-end'
MESSAGE_LIST = '.qwenpaw-bubble-list-scroll'
# Welcome screen (check input visibility)
WELCOME_TEXT = CHAT_INPUT
QUICK_ACTIONS = '.quick-action'
# Session management (right-side "All Chats" drawer).
# Post v2.0.0 redesign the SessionItem container is a hashed CSS-Module
# class (``styles.item``) carrying ``role="button"``; the legacy
# ``chatSessionItem`` class is gone. Anchor on the drawer list wrapper +
# role, keeping the old class as a fallback for older builds.
SESSION_ITEM = (
'[class*=listWrapper] div[class*="sessionItem-module__item"], '
'[class*=chatSessionItem]'
)
SESSION_ACTIVE = (
'[class*=listWrapper] div[class*="sessionItem-module__item"][class*=active], '
'[class*=chatSessionItem][class*=active]'
)
SESSION_NAME = (
'[class*=listWrapper] div[class*="sessionItem-module__item"] [class*=name], '
'[class*=chatSessionItem] [class*=name]'
)
# SessionItem actions now live behind a "more" button (SparkMoreLine)
# that opens an antd Dropdown menu (Pin / Rename / Archive / Delete).
SESSION_MORE_BTN = '[class*=moreBtn]'
# ``:text-is`` is exact so "Pin" does not also match "Unpin".
SESSION_MENU_PIN = (
'.qwenpaw-dropdown-menu-item:has-text("Pin"), '
'.qwenpaw-dropdown-menu-item:has-text("置顶")'
)
SESSION_MENU_UNPIN = (
'.qwenpaw-dropdown-menu-item:has-text("Unpin"), '
'.qwenpaw-dropdown-menu-item:has-text("取消置顶")'
)
SESSION_MENU_RENAME = (
'.qwenpaw-dropdown-menu-item:has-text("Rename"), '
'.qwenpaw-dropdown-menu-item:has-text("重命名")'
)
SESSION_MENU_DELETE = (
'.qwenpaw-dropdown-menu-item:has-text("Delete"), '
'.qwenpaw-dropdown-menu-item:has-text("删除")'
)
# Inline rename input rendered when a SessionItem enters edit mode.
SESSION_RENAME_INPUT = 'input[class*=renameInput]'
# Conversation search box inside the drawer (filters sessions by title).
SESSION_SEARCH_INPUT = '[class*=searchContainer] input'
# Legacy hover-button selectors (kept for older builds / fallbacks).
SESSION_PIN_BTN = 'button:has(.spark-icon-spark-mark-line), button:has(.anticon-pushpin)'
SESSION_EDIT_BTN = 'button:has(.spark-icon-spark-edit-line), button:has(.anticon-edit)'
SESSION_DELETE_BTN = 'button:has(.spark-icon-spark-delete-line), button:has(.anticon-delete)'
# --- Tool approval level toggle (composer / sender area) — upstream #5685 ---
# A single antd Tag whose text is one of the 4 levels; clicking it opens a
# dropdown of exactly 4 options. No CSS-module class or data-testid, so we
# anchor on the level texts (browser locale is en-US; ZH kept as fallback).
APPROVAL_LEVELS = {
"STRICT": ("Strict Mode", "严格模式"),
"SMART": ("Smart Mode", "智能模式"),
"AUTO": ("Auto Mode", "自动模式"),
"OFF": ("Off Mode", "关闭模式"),
}
_APPROVAL_LABEL_RE = re.compile(
r"Strict Mode|Smart Mode|Auto Mode|Off Mode|"
r"严格模式|智能模式|自动模式|关闭模式"
)
# Only items inside the currently-open dropdown (antd keeps closed menus in
# the DOM with a ``-hidden`` modifier).
APPROVAL_MENU_ITEM = (
'.qwenpaw-dropdown:not(.qwenpaw-dropdown-hidden) '
'.qwenpaw-dropdown-menu-item'
)
# Settings and model
MODEL_SELECTOR = '.qwenpaw-dropdown-trigger'
MODEL_OPTION = '.qwenpaw-dropdown-menu-item'
AGENT_SELECTOR = '.qwenpaw-select-selector'
# --- Sidebar agent switcher (components/AgentSelector) ---
# The antd Select sits inside a CSS-module wrapper whose hashed class
# keeps the "agentSelector" basename; scoping avoids other Selects.
AGENT_SWITCHER = '[class*="agentSelector"] .qwenpaw-select-selector'
AGENT_SWITCHER_VALUE = (
'[class*="agentSelector"] .qwenpaw-select-selection-item'
)
AGENT_SWITCHER_OPTION = (
'.qwenpaw-select-dropdown:not(.qwenpaw-select-dropdown-hidden) '
'.qwenpaw-select-item-option'
)
# --- Slash-command suggestion popup (@ant-design/x Suggestion) ---
# Opens while the input starts with "/" and has no whitespace yet.
# Two nodes carry .qwenpaw-suggestion (inline content + the cascader
# dropdown); anchor on the dropdown, excluding its hidden state.
SUGGESTION_POPUP = (
'.qwenpaw-suggestion.qwenpaw-select-dropdown'
':not(.qwenpaw-select-dropdown-hidden)'
)
SUGGESTION_ITEM = '.qwenpaw-suggestion-item'
# --- Sidebar session date groups — upstream #5643 ---
# SidebarSessionList renders one <button class={styles.groupLabel}> per
# non-empty bucket (Pinned / Today / Within 7 days / Within 30 days /
# Earlier); clicking toggles collapse. "month" + "older" start collapsed.
SIDEBAR_GROUP_LABEL = 'div[role="button"][class*="SessionGroupHeader"]'
SIDEBAR_DATE_LABEL = '[data-date-group]'
SIDEBAR_GROUP_CHEVRON = 'span[class*="groupChevron"]'
SIDEBAR_GROUP_TEXTS = {
"pinned": ("Pinned", "置顶"),
"today": ("Today", "今天"),
"week": ("Within 7 days", "7天内"),
"month": ("Within 30 days", "30天内"),
"older": ("Earlier", "更早"),
}
# --- Non-owner tab banner — upstream #5664 ---
# antd <Alert type="info" banner> injected into the sender beforeUI slot
# when this tab lost the qwenpaw:queue-owner:<sessionId> Web Lock. Appears
# only after a 300ms ownershipResolved fallback timer.
QUEUE_BANNER = '.qwenpaw-alert-banner'
_QUEUE_BANNER_RE = re.compile(
r"This tab queues only|当前标签页仅入队"
)
# Action buttons
COPY_BTN = 'span[title="复制"]'
# Tool and skill details
TOOL_TOGGLE = '.qwenpaw-operate-card-header-arrow'
TOOL_DETAILS = '.qwenpaw-operate-card'
# Errors and toasts (SUCCESS_MESSAGE / ERROR_MESSAGE inherited from BasePage)
COPY_SUCCESS = '.qwenpaw-message-success'
# Drawer and dialog
DRAWER_CLOSE = '[class*=headerRight] button'
CONFIRM_BTN = 'button:has-text("确认"), button:has-text("OK"), .qwenpaw-btn-primary:has-text("确定")'
CANCEL_BTN = 'button:has-text("取消"), button:has-text("Cancel")'
# ========== Robust "button disabled" detection JS snippets ==========
# Different UI frameworks express disabled differently; we must check all four channels:
# 1. Native button.disabled property
# 2. disabled attribute
# 3. aria-disabled="true"
# 4. Framework-injected disabled / loading class
# Hitting any of them is treated as disabled.
_JS_BTN_IS_DISABLED = """() => {
const btn = document.querySelector(
'button.qwenpaw-sender-actions-btn.qwenpaw-btn-primary'
);
if (!btn) return false;
if (btn.disabled === true) return true;
if (btn.hasAttribute('disabled')) return true;
if (btn.getAttribute('aria-disabled') === 'true') return true;
const cls = btn.className || '';
if (/qwenpaw-btn-disabled|qwenpaw-btn-loading|is-disabled|is-loading/.test(cls)) {
return true;
}
return false;
}"""
_JS_BTN_IS_ENABLED = """() => {
const btn = document.querySelector(
'button.qwenpaw-sender-actions-btn.qwenpaw-btn-primary'
);
if (!btn) return false;
if (btn.disabled === true) return false;
if (btn.hasAttribute('disabled')) return false;
if (btn.getAttribute('aria-disabled') === 'true') return false;
const cls = btn.className || '';
if (/qwenpaw-btn-disabled|qwenpaw-btn-loading|is-disabled|is-loading/.test(cls)) {
return false;
}
return true;
}"""
# ========== Initialization ==========
def __init__(self, page: Page):
super().__init__(page)
logger.info("ChatPage initialized")
# ========== Page navigation ==========
def open(self) -> "ChatPage":
"""Open the Chat page."""
logger.info("Opening Chat page")
self.goto()
# The chat page keeps SSE connections open, so ``networkidle``
# never fires. Wait for the textarea to be visible instead —
# that's a strong signal that React has booted and the page is
# interactive.
self.page.locator(self.CHAT_INPUT).first.wait_for(
state="visible", timeout=self.timeout
)
self.step_shot("open_chat_page")
return self
def is_loaded(self) -> bool:
"""Check whether the page has finished loading."""
try:
# Check whether the input box or welcome text is present
return (
self.assert_visible(self.CHAT_INPUT, timeout=5000) or
self.assert_visible(self.WELCOME_TEXT, timeout=5000)
)
except Exception:
return False
# ========== New chat ==========
def create_new_chat(self) -> "ChatPage":
"""
Create a new chat.
Returns:
self
"""
logger.info("Creating new chat")
# Reset send state (a new session does not need to wait for the previous AI response)
if hasattr(self, '_has_sent_message'):
del self._has_sent_message
self._ai_count_before_send = 0
new_chat_btn = self.find(self.NEW_CHAT_BTN)
if new_chat_btn.count() > 0:
new_chat_btn.click()
# Wait for page navigation and full load
self.page.wait_for_load_state("networkidle")
self.page.locator(self.CHAT_INPUT).wait_for(state="visible", timeout=10000)
self.step_shot("create_new_chat_done")
return self
def verify_welcome_screen(self) -> bool:
"""
Verify the welcome screen is shown.
Returns:
whether the welcome screen is visible
"""
logger.info("Verifying welcome screen")
result = self.assert_visible(self.WELCOME_TEXT, timeout=5000)
# Immediately clear any lingering hover/focus state to avoid polluting subsequent send_message
# (previously observed: after calling this method, the first send_message would never see the button become disabled)
try:
self.page.mouse.move(0, 0)
self.page.keyboard.press("Escape")
except Exception:
pass
return result
def get_quick_actions(self) -> List[Locator]:
"""Get the list of quick action buttons."""
return self.find_all(self.QUICK_ACTIONS)
def click_quick_action(self, index: int = 0) -> "ChatPage":
"""
Click a quick action button.
Args:
index: button index
Returns:
self
"""
actions = self.get_quick_actions()
if actions and index < len(actions):
actions[index].click()
logger.info(f"Clicked quick action at index {index}")
return self
# ========== Send message ==========
def send_message(self, text: str) -> "ChatPage":
"""
Send a message (strict-validation version).
Strictly isolated from the previous round:
1. Snapshot the baseline (AI / User message counts) before any DOM change.
2. Must wait for the previous round's "button enabled" before entering the next round
(avoid interrupting while still streaming).
3. After clicking send, must observe "button becomes disabled" -- the only trustworthy
signal that "a new round really started".
Not seeing disabled = this round did not take effect -> raise so the upstream test truly fails.
Args:
text: message content
Returns:
self
Raises:
AssertionError / TimeoutError: when send did not actually trigger a new AI response round.
"""
logger.info(f"Sending message: {text[:50]}...")
# ---- Entry sanitation: clear leftover popups/focus (avoid side effects from verify_* etc.) ----
try:
self.page.keyboard.press("Escape")
self.page.mouse.move(10, 10)
self.wait(150)
except Exception:
pass
# ---- Before a new round: record the baseline (must be before any fill / click) ----
self._ai_count_before_send = self.page.locator(self.AI_MESSAGE).count()
user_count_before = self.page.locator(self.USER_MESSAGE).count()
logger.info(
f"[send_message] baseline: ai={self._ai_count_before_send}, "
f"user={user_count_before}"
)
# ---- Wait for the previous round to truly finish (dual signal: button recovered OR content stable >= 1.5s) ----
# Design: use the same "dual signal" as wait_for_ai_response to avoid getting stuck on the known frontend bug where streaming signals are lost.
# Only needs to wait if there is history (skip when user_count_before==0 on the first round).
# Timeout shortened to 8s: the previous wait_for_ai_response already released, this is just a safety wait until UI is fully idle.
if user_count_before > 0:
try:
self.page.wait_for_function(
"""() => {
// Path A: button has recovered to enabled
const btn = document.querySelector(
'button.qwenpaw-sender-actions-btn.qwenpaw-btn-primary'
);
if (btn) {
const cls = btn.className || '';
const disabledByCls = /qwenpaw-btn-disabled|qwenpaw-btn-loading|is-disabled|is-loading/.test(cls);
const disabledByAttr = btn.disabled === true
|| btn.hasAttribute('disabled')
|| btn.getAttribute('aria-disabled') === 'true';
if (!disabledByAttr && !disabledByCls) return true;
}
// Path B: last AI bubble content unchanged for 1.5s in a row (release even if button is forever disabled)
const aiMsgs = document.querySelectorAll(
'.qwenpaw-bubble.qwenpaw-bubble-start'
);
if (aiMsgs.length === 0) return true; // No AI bubble, release directly
const last = aiMsgs[aiMsgs.length - 1];
const raw = (last.innerText || '').trim();
const key = '__qwenpaw_send_idle_cache__';
const now = Date.now();
const cache = window[key] || {};
if (cache.text !== raw) {
window[key] = { text: raw, since: now };
return false;
}
return (now - cache.since) >= 1500;
}""",
timeout=8000,
)
logger.info("[send_message] previous round confirmed idle")
except (TimeoutError, AssertionError, Exception):
logger.warning(
"[send_message] previous AI round idle-check timeout (8s), "
"proceeding anyway"
)
finally:
try:
self.page.evaluate(
"() => { try { delete window.__qwenpaw_send_idle_cache__; } catch(e) {} }"
)
except Exception:
pass
# ---- Fill the input box ----
input_box = self.page.locator(self.CHAT_INPUT)
input_box.focus()
self.wait(300)
input_box.fill("")
self.wait(200)
input_box.fill(text)
self.wait(500)
# Screenshot: input done, before clicking send
self.step_shot(f"send_before_click_{text[:20]}")
# ---- Trigger send ----
send_btn = self.page.locator(self.SEND_BTN)
if send_btn.is_visible() and send_btn.is_enabled():
send_btn.click()
else:
input_box.press("Enter")
# ---- Strict check: user bubble must +1 (proof the frontend actually sent the message) ----
try:
self.page.wait_for_function(
"""(expected) => {
const msgs = document.querySelectorAll(
'.qwenpaw-bubble.qwenpaw-bubble-end'
);
return msgs.length > expected;
}""",
arg=user_count_before,
timeout=15000,
)
logger.info("[send_message] user bubble appeared")
except (TimeoutError, AssertionError, Exception):
logger.warning("[send_message] user bubble missing, retrying with Enter")
input_box = self.page.locator(self.CHAT_INPUT)
input_box.focus()
self.wait(200)
input_box.press("Enter")
# Verify again after retry; if still failing, raise for real
self.page.wait_for_function(
"""(expected) => {
const msgs = document.querySelectorAll(
'.qwenpaw-bubble.qwenpaw-bubble-end'
);
return msgs.length > expected;
}""",
arg=user_count_before,
timeout=15000,
)
# ---- Soft check: try to observe the send button becoming disabled (auxiliary signal only, not enforced) ----
# Note: previously treating "must see disabled" as a hard condition introduced "false negatives" -- in some cases
# the backend responds very fast, button flashes enabled->disabled->enabled, and we miss the disabled state and error out.
# In fact, the user bubble appearing = the message has truly been sent; the "real start" of a new round is judged by wait_for_ai_response
# using "AI bubble count +1" and "content stable" -- that is the gold standard.
# Here we only do a best-effort observation, with timeout shortened to 3s and no error raised.
try:
self.page.wait_for_function(
self._JS_BTN_IS_DISABLED,
timeout=3000,
)
self._send_triggered_round = True
logger.info("[send_message] send button became disabled (round started)")
except (TimeoutError, AssertionError, Exception):
# Not seeing disabled does not mean failure -- maybe the backend was too fast, or the frontend button state machine is buggy.
# Delegate the "did AI actually reply" judgment fully to wait_for_ai_response.
self._send_triggered_round = True # Default trust: the user bubble already appeared
logger.info(
"[send_message] send button disabled-state not observed within 3s; "
"trusting user-bubble signal and delegating to wait_for_ai_response"
)
# Screenshot: user message sent, AI about to reply
self.step_shot("send_after_user_bubble")
return self
def send_message_and_wait(self, text: str, timeout: int = 30000) -> "ChatPage":
"""
Send a message and wait for the AI reply.
Args:
text: message content
timeout: wait timeout
Returns:
self
"""
self.send_message(text)
self.wait_for_ai_response(timeout)
return self
def get_user_messages(self) -> List[Locator]:
"""Get all user messages."""
return self.page.locator(self.USER_MESSAGE).all()
def get_ai_messages(self) -> List[Locator]:
"""Get all AI messages."""
return self.page.locator(self.AI_MESSAGE).all()
def get_all_messages(self) -> List[Locator]:
"""Get all messages."""
return self.page.locator(self.MESSAGE_CONTAINER).all()
def get_last_ai_message(self) -> Optional[Locator]:
"""Get the last AI message."""
messages = self.get_ai_messages()
return messages[-1] if messages else None
def wait_for_ai_response(self, timeout: int = 30000) -> Optional[Locator]:
"""
Wait for the AI reply to truly complete (strict version, eliminate false positives).
All four gates below must pass in order before "AI really finished replying"; any gate failure -> return None
so the upstream test truly FAILs:
Gate 0 send_message must have actually triggered a new round (button disabled state was observed)
Gate 1 AI bubble count > baseline (new bubble was truly born)
Gate 2 Send button transitioned from disabled -> enabled (streaming really ended)
Gate 3 The latest AI bubble content is stable (innerText unchanged for >= 800ms in a row)
and after stripping the "Thinking" placeholder, still has >= 2 characters
Args:
timeout: overall timeout (ms), shared budget across gates
Returns:
Locator of the last AI message; returns None on any gate failure.
"""
logger.info(f"Waiting for AI response (timeout: {timeout}ms)")
ai_locator = self.page.locator(self.AI_MESSAGE)
count_before_send = getattr(
self, "_ai_count_before_send", ai_locator.count()
)
logger.info(
f"[wait_ai] baseline_count={count_before_send}, "
f"current_count={ai_locator.count()}"
)
# ---- Gate 0: did send actually trigger a new round ----
if not getattr(self, "_send_triggered_round", True):
logger.error(
"[wait_ai] send_message never observed send-button=disabled, "
"no new round was triggered. Treat as failure."
)
return None
# ---- Gate 1: wait for a new AI bubble to appear ----
try:
self.page.wait_for_function(
"""(expectedCount) => {
const aiMsgs = document.querySelectorAll(
'.qwenpaw-bubble.qwenpaw-bubble-start'
);
return aiMsgs.length > expectedCount;
}""",
arg=count_before_send,
timeout=timeout,
)
logger.info("[wait_ai] gate-1 PASS: new AI bubble appeared")
except (TimeoutError, AssertionError, Exception) as e:
logger.error(
f"[wait_ai] gate-1 FAIL: new AI bubble never appeared "
f"({type(e).__name__})"
)
return None
# ---- Gate 2 + Gate 3 combined: wait for "AI content stable >= 2.5s" or "button back to enabled" (whichever first) ----
# Design motivation (based on real log observation):
# - The system under test has a known bug: streaming-end signals are often lost, the button stays forever disabled,
# but the AI reply content has actually been fully appended. Waiting forever for the button -> every test gets dragged to 90s then FAILs.
# - Solution: use "content stable" as the primary signal (closer to real user perception),
# and "button recovered" as the fast-path accelerator; whichever signal is ready first releases.
# - Still filter out the "Thinking / Loading" placeholder + require >= 2 real characters -> eliminates false positives.
# - Stability window widened to 2500ms (more stable than the original 800ms; avoids misjudging long-token streaming gaps).
stability_timeout = min(timeout, 30000)
passed_via = None
try:
self.page.wait_for_function(
"""(expectedCount) => {
// Path A: button transitioned from disabled back to enabled -> streaming really ended
const btn = document.querySelector(
'button.qwenpaw-sender-actions-btn.qwenpaw-btn-primary'
);
let btnEnabled = false;
if (btn) {
const cls = btn.className || '';
const disabledByCls = /qwenpaw-btn-disabled|qwenpaw-btn-loading|is-disabled|is-loading/.test(cls);
const disabledByAttr = btn.disabled === true
|| btn.hasAttribute('disabled')
|| btn.getAttribute('aria-disabled') === 'true';
btnEnabled = !disabledByAttr && !disabledByCls;
}
// Path B: AI bubble content unchanged for 2500ms in a row and >= 2 chars after stripping placeholders
const aiMsgs = document.querySelectorAll(
'.qwenpaw-bubble.qwenpaw-bubble-start'
);
if (aiMsgs.length <= expectedCount) {
return false; // No new bubble at all; definitely cannot release
}
const last = aiMsgs[aiMsgs.length - 1];
const raw = (last.innerText || '').trim();
const stripped = raw
.replace(/Thinking/gi, '')
.replace(/Loading/gi, '')
.trim();
const hasRealText = stripped.length >= 2;
// Content stability check (only computed when there is real text)
let contentStable = false;
if (hasRealText) {
const key = '__qwenpaw_ai_stable_cache__';
const now = Date.now();
const cache = window[key] || {};
if (cache.text !== raw) {
window[key] = { text: raw, since: now };
} else if ((now - cache.since) >= 1500) {
contentStable = true;
}
}
// Path A priority (button recovered + at least real text -> release immediately)
if (btnEnabled && hasRealText) {
window.__qwenpaw_wait_passed_via__ = 'btn_enabled';
return true;
}
// Path B fallback (release on content stability even if button is forever disabled)
if (contentStable) {
window.__qwenpaw_wait_passed_via__ = 'content_stable';
return true;
}
return false;
}""",
arg=count_before_send,
timeout=stability_timeout,
)
try:
passed_via = self.page.evaluate(
"() => window.__qwenpaw_wait_passed_via__ || 'unknown'"
)
except Exception:
passed_via = "unknown"
logger.info(
f"[wait_ai] gate-2/3 PASS via '{passed_via}' "
f"(streaming considered done)"
)
except (TimeoutError, AssertionError, Exception) as e:
try:
last_text = ai_locator.last.inner_text()[:200]
except Exception:
last_text = "<unreadable>"
logger.error(
f"[wait_ai] gate-2/3 FAIL within {stability_timeout}ms "
f"({type(e).__name__}). Neither button re-enabled nor content stabilized. "
f"Last bubble text: {last_text!r}"
)
# Failure screenshot for post-mortem
self.step_shot("wait_ai_FAIL_gate23")
return None
finally:
# Clean up window cache so it doesn't affect the next round's judgment
try:
self.page.evaluate(
"() => { try { "
"delete window.__qwenpaw_ai_stable_cache__; "
"delete window.__qwenpaw_wait_passed_via__; "
"} catch(e) {} }"
)
except Exception:
pass
# Screenshot: final state after AI fully replied
self.step_shot(f"ai_response_complete_{passed_via or 'unknown'}")
return ai_locator.last
# ========== Message actions ==========
def copy_last_message(self) -> bool:
"""
Copy the last AI message.
Returns:
whether the copy succeeded
"""
logger.info("Copying last AI message")
ai_msg = self.get_last_ai_message()
if not ai_msg:
logger.warning("No AI message to copy")
return False
copy_btn = ai_msg.locator(self.COPY_BTN).first
if copy_btn.count() > 0:
copy_btn.click()
self.wait(500)
# Verify copy success
if self.assert_visible(self.COPY_SUCCESS, timeout=3000):
logger.info("Message copied successfully")
self.step_shot("copy_success")
return True
logger.warning("Copy failed or not available")
self.step_shot("copy_failed")
return False
def get_message_text(self, message_locator: Locator) -> str:
"""
Get the text content of a message.
Args:
message_locator: message Locator
Returns:
message text
"""
return message_locator.inner_text()
def verify_message_contains(self, message_locator: Locator, expected_text: str) -> bool:
"""
Verify the message contains the given text.
Args:
message_locator: message Locator
expected_text: text expected to be present
Returns:
whether the message contains the text
"""
text = self.get_message_text(message_locator)
return expected_text.lower() in text.lower()
# ========== File upload ==========
def upload_file(self, file_path: str) -> "ChatPage":
"""
Upload a file.
Args:
file_path: path to the file
Returns:
self
"""
logger.info(f"Uploading file: {file_path}")
self.step_shot("upload_before")
# Set the file directly via the file input (no need to click the upload button)
file_input = self.page.locator(self.FILE_INPUT)
file_input.set_input_files(file_path)
self.wait(2000) # Wait for upload to complete
logger.info("File upload initiated")
self.step_shot("upload_after")
return self
def verify_file_uploaded(self, timeout: int = 10000) -> bool:
"""
Verify the file was uploaded successfully.
Args:
timeout: timeout in ms
Returns:
whether the upload succeeded
"""
file_preview_selector = '.qwenpaw-upload-list-item, .qwenpaw-sender-content [class*="file"], [class*="attachment"]'
return self.assert_visible(file_preview_selector, timeout=timeout)
# ========== Session management ==========
def open_session_list(self) -> "ChatPage":
"""Open the session list (with page state self-healing)."""
logger.info("Opening session list")
# Close any leftover dropdowns / popovers first to prevent button occlusion
try:
self.page.keyboard.press("Escape")
self.page.mouse.move(0, 0) # Move the mouse away to avoid triggering other hovers
except Exception:
pass
self.wait(300)
# Idempotency: if session items are already visible, the panel
# is open — skip the toggle click to avoid closing it.
existing = self.page.locator(self.SESSION_ITEM).first
if existing.count() > 0 and existing.is_visible():
logger.info("[open_session_list] panel already open, skipping toggle")
self.step_shot("session_list_opened")
return self
# Fallback: if the button is not found in a short time (maybe the sidebar is hidden by an abnormal state), try reloading the page
session_btn_locator = self.page.locator(self.SESSION_LIST_BTN).first
try:
session_btn_locator.wait_for(state="visible", timeout=5000)
except (TimeoutError, Exception):
logger.warning(
"[open_session_list] session list button not visible in 5s, "
"page may be in a stuck state, trying to recover by reloading"
)
try:
self.page.reload(wait_until="domcontentloaded", timeout=15000)
self.wait(1500)
session_btn_locator.wait_for(state="visible", timeout=10000)
except Exception as e:
logger.warning(f"[open_session_list] reload-recovery also failed: {e}")
self.step_shot("open_session_list_btn_invisible_after_reload")
# Do not raise; let the upstream try/except handle it
return self
try:
session_btn_locator.click(timeout=8000)
except Exception:
logger.warning("Normal click failed, trying force click")
try:
session_btn_locator.click(force=True, timeout=5000)
except Exception as e:
logger.warning(f"[open_session_list] force click also failed: {e}")
self.step_shot("open_session_list_click_failed")
return self
# Wait for the session list drawer to finish rendering
try:
self.page.locator(self.SESSION_ITEM).first.wait_for(state="visible", timeout=8000)
except (TimeoutError, Exception):
logger.warning("Session list may be empty or slow to render")
self.wait(500)
self.step_shot("session_list_opened")
return self
def close_session_list(self) -> "ChatPage":
"""Close the session list.
The panel may be rendered as an antd Drawer (``.qwenpaw-drawer``)
or as an embedded panel (``[class*=historyPanel]``). The close
button is the **last** button inside ``[class*=headerRight]``
(the first is pin/unpin). If neither selector matches, fall back
to clicking the session-list toggle button which toggles the
panel closed.
"""
logger.info("Closing session list")
for container in (
'.qwenpaw-drawer',
'[class*="historyPanel"]',
'[class*="embeddedPanel"]',
):
close_btn = self.page.locator(
f'{container} {self.DRAWER_CLOSE}'
)
if close_btn.count() > 0:
close_btn.last.click()
self.wait(500)
return self
# Fallback: toggle the session-list button to close the panel.
toggle = self.page.locator(self.SESSION_LIST_BTN).first
if toggle.count() > 0 and toggle.is_visible():
toggle.click()
self.wait(500)
return self
def get_session_items(self) -> List[Locator]:
"""Get all session items."""
return self.page.locator(self.SESSION_ITEM).all()
def get_session_count(self) -> int:
"""Get the number of sessions."""
return len(self.get_session_items())
def switch_to_session(self, index: int = 0) -> "ChatPage":
"""
Switch to the session at the given index.
Args:
index: session index
Returns:
self
"""
sessions = self.get_session_items()
if sessions and index < len(sessions):
target = sessions[index]
try:
target.scroll_into_view_if_needed(timeout=5000)
target.wait_for(state="visible", timeout=5000)
except Exception as e:
logger.warning(f"Session {index} visibility check failed: {e}")
target.click()
self.wait(1000)
logger.info(f"Switched to session at index {index}")
self.step_shot(f"switch_to_session_{index}")
return self
def _open_session_menu(self, index: int) -> bool:
"""Hover a session item and open its actions dropdown.
The dropdown is triggered by the SparkMoreLine "more" button and
holds Pin / Rename / Archive / Delete items. Returns True when the
menu is visible.
The ``moreBtn`` is a ``<span>`` that is ``pointer-events:none`` until
the row is ``:hover``-ed, and antd opens the menu on a real click. In
headless CI the CSS ``:hover`` can be lost between hovering the row and
clicking, so a plain/force click may land on the element *behind* the
span and never open the menu. We therefore hover the row and the
button, try a normal click, and fall back to a DOM
``dispatchEvent('click')`` that bypasses the pointer-events gate
(React's delegated onClick still fires). Two attempts total.
"""
sessions = self.get_session_items()
if not sessions or index >= len(sessions):
logger.warning(f"Session at index {index} not found")
return False
# The sidebar is a virtual list: rows are recycled, so a locator
# captured via .all() can detach mid-interaction. Re-resolve by
# nth() right before each interaction attempt instead.
target = self.page.locator(self.SESSION_ITEM).nth(index)
# antd keeps closed menus in the DOM with a ``-hidden`` modifier; the
# open one is the menu WITHOUT it.
open_menu_item = (
'.qwenpaw-dropdown:not(.qwenpaw-dropdown-hidden) '
'.qwenpaw-dropdown-menu-item'
)
def _menu_visible(timeout: int) -> bool:
try:
self.page.locator(open_menu_item).first.wait_for(
state="visible", timeout=timeout
)
return True
except (TimeoutError, Exception):
return False
for attempt in range(2):
# Reset any stale hover / overlay before (re)trying.
try:
self.page.mouse.move(0, 0)
except Exception:
pass
# Virtual list: off-viewport rows are not in the DOM at all.
# Scroll the list container so the target row gets rendered
# before resolving it.
try:
if not target.is_visible():
self.page.locator(
'[class*="listWrapper"] [class*="scroll"], '
'[class*="listWrapper"]'
).first.evaluate(
"el => el.scrollTo({top: el.scrollHeight})"
)
self.wait(500)
except Exception as exc:
logger.warning(f"[_open_session_menu] scroll failed: {exc}")
try:
target.scroll_into_view_if_needed(timeout=5000)
target.hover(timeout=8000)
except Exception:
try:
target.hover(force=True, timeout=5000)
except Exception as exc:
logger.warning(f"[_open_session_menu] hover failed: {exc}")
self.wait(300)
more_btn = target.locator(self.SESSION_MORE_BTN).first
if more_btn.count() == 0:
logger.warning("[_open_session_menu] more button not found")
return False
# Hover the button so the row stays :hover-ed (moreBtn is
# pointer-events:none otherwise), then click.
try:
more_btn.hover(timeout=3000)
except Exception:
pass
try:
more_btn.click(timeout=4000)
except Exception:
pass
if _menu_visible(4000):
self.wait(200)
return True
# The click may have been swallowed by the pointer-events gate;
# fire it via the DOM so React's delegated onClick still opens the
# menu.
try:
more_btn.dispatch_event("click")
except Exception as exc:
logger.warning(
f"[_open_session_menu] dispatch click failed: {exc}"
)
if _menu_visible(3000):
self.wait(200)
return True
logger.warning(
f"[_open_session_menu] dropdown did not appear "
f"(attempt {attempt + 1})"
)
return False
def rename_session(self, index: int, new_name: str) -> "ChatPage":
"""Rename a session via more-menu → Rename → inline input → Enter."""
logger.info(f"Renaming session {index} to: {new_name}")
if not self._open_session_menu(index):
self.step_shot(f"rename_session_{index}_menu_failed")
return self
rename_item = self.page.locator(self.SESSION_MENU_RENAME).first
if rename_item.count() == 0 or not rename_item.is_visible():
logger.warning("Rename menu item not found, skipping rename")
self.page.keyboard.press("Escape")
return self
rename_item.click()
self.wait(500)
# Inline rename input (autofocus). Fall back to any visible input in
# the drawer if the class-based selector misses.
rename_input = self.page.locator(self.SESSION_RENAME_INPUT).first
if rename_input.count() == 0 or not rename_input.is_visible():
rename_input = self.page.locator(
'[class*=listWrapper] input, .qwenpaw-drawer input'
).first
if rename_input.count() == 0 or not rename_input.is_visible():
logger.warning("Rename input not found, skipping rename")
return self
rename_input.fill(new_name)
self.step_shot(f"rename_input_filled_{new_name[:20]}")
rename_input.press("Enter")
self.wait(1000)
logger.info(f"Session renamed to: {new_name}")
self.step_shot(f"rename_done_{new_name[:20]}")
return self
def pin_session(self, index: int) -> "ChatPage":
"""Pin a session via more-menu → Pin."""
logger.info(f"Pinning session at index {index}")
if not self._open_session_menu(index):
self.step_shot(f"pin_session_{index}_menu_failed")
return self
pin_item = self.page.locator(self.SESSION_MENU_PIN).first
if pin_item.count() == 0 or not pin_item.is_visible():
# No "Pin" item means it is already pinned ("Unpin" shown).
logger.info("Pin menu item not present (already pinned?)")
self.page.keyboard.press("Escape")
return self
pin_item.click()
self.wait(1000)
logger.info("Session pinned")
self.step_shot(f"pin_session_{index}_done")
return self
def delete_session(self, index: int) -> "ChatPage":
"""Delete a session via more-menu → Delete (confirm modal if shown)."""
logger.info(f"Deleting session at index {index}")
sessions_before = self.get_session_count()
if not self._open_session_menu(index):
self.step_shot(f"delete_session_{index}_menu_failed")
return self
del_item = self.page.locator(self.SESSION_MENU_DELETE).first
if del_item.count() == 0 or not del_item.is_visible():
logger.warning("Delete menu item not found")
self.page.keyboard.press("Escape")
self.step_shot(f"delete_session_{index}_item_missing")
return self
del_item.click()
self.wait(800)
# A confirmation modal may appear; confirm it when present.
confirm = self.page.locator(
'.qwenpaw-modal-confirm-btns button.qwenpaw-btn-dangerous, '
'.qwenpaw-modal button.qwenpaw-btn-dangerous, '
'.qwenpaw-modal-confirm-btns button.qwenpaw-btn-primary'
).first
try:
if confirm.count() > 0 and confirm.is_visible(timeout=1500):
confirm.click()
self.wait(500)
except (TimeoutError, Exception):
pass
self.wait(800)
logger.info(
f"Session deleted (before: {sessions_before}, "
f"after: {self.get_session_count()})"
)
self.step_shot(f"delete_session_{index}_done")
return self
def verify_pinned_session(self) -> bool:
"""Verify the top session is pinned.
A pinned session's more-menu shows "Unpin" instead of "Pin"; we
re-open the first session's menu and look for that item.
"""
if not self._open_session_menu(0):
return False
unpin = self.page.locator(self.SESSION_MENU_UNPIN).first
result = unpin.count() > 0 and unpin.is_visible()
try:
self.page.keyboard.press("Escape")
except Exception:
pass
self.wait(300)
return result
def search_sessions(self, keyword: str) -> "ChatPage":
"""Filter the drawer session list via the conversation search box."""
box = self.page.locator(self.SESSION_SEARCH_INPUT).first
box.wait_for(state="visible", timeout=5000)
box.fill(keyword)
self.wait(800)
return self
def clear_session_search(self) -> "ChatPage":
"""Clear the drawer conversation search box."""
box = self.page.locator(self.SESSION_SEARCH_INPUT).first
if box.count() > 0 and box.is_visible():
box.fill("")
self.wait(800)
return self
# ========== Tool approval level toggle ==========
def get_approval_toggle(self) -> Locator:
"""Locate the approval-level Tag in the composer (matches any level)."""
return (
self.page.locator("span.qwenpaw-tag")
.filter(has_text=self._APPROVAL_LABEL_RE)
.first
)
def open_approval_menu(self) -> "ChatPage":
"""Click the approval Tag and wait for its dropdown to render."""
self.get_approval_toggle().click()
self.page.locator(self.APPROVAL_MENU_ITEM).first.wait_for(
state="visible", timeout=5000
)
self.wait(200)
return self
def get_approval_menu_items(self) -> List[Locator]:
"""Return the visible approval dropdown items (expected: 4)."""
return self.page.locator(self.APPROVAL_MENU_ITEM).all()
def select_approval_level(self, level: str) -> "ChatPage":
"""Open the menu and pick a level by key (STRICT/SMART/AUTO/OFF)."""
en, zh = self.APPROVAL_LEVELS[level]
self.open_approval_menu()
item = self.page.locator(
f'{self.APPROVAL_MENU_ITEM}:has-text("{en}"), '
f'{self.APPROVAL_MENU_ITEM}:has-text("{zh}")'
).first
item.click()
self.wait(500)
self.step_shot(f"approval_select_{level}")
return self
def get_approval_storage_entries(self) -> dict:
"""Read all ``approval_level-*`` localStorage entries as {key: value}."""
return self.page.evaluate(
"""() => {
const out = {};
for (let i = 0; i < localStorage.length; i++) {
const k = localStorage.key(i);
if (k && k.indexOf('approval_level-') === 0) {
out[k] = localStorage.getItem(k);
}
}
return out;
}"""
)
# ========== Sidebar date groups (upstream #5643) ==========
def get_sidebar_group_header(self, group: str) -> Locator:
"""Locator for one sidebar date-bucket header.
Args:
group: bucket key — pinned / today / week / month / older.
Upstream re-architected the sidebar: date buckets now render as
non-collapsible ``SessionDateHeader`` rows carrying a
``data-date-group`` attribute, nested inside collapsible user
groups.
"""
en, zh = self.SIDEBAR_GROUP_TEXTS[group]
return self.page.locator(
f'{self.SIDEBAR_DATE_LABEL}[data-date-group="{group}"], '
f'{self.SIDEBAR_DATE_LABEL}:has-text("{en}"), '
f'{self.SIDEBAR_DATE_LABEL}:has-text("{zh}")'
).first
def toggle_sidebar_user_group(self) -> "ChatPage":
"""Click the first collapsible user-group header."""
logger.info("Toggling the first sidebar user group")
self.page.locator(self.SIDEBAR_GROUP_LABEL).first.click()
self.wait(300)
return self
def toggle_sidebar_group(self, group: str) -> "ChatPage":
"""Click a sidebar group header to collapse / expand it."""
logger.info(f"Toggling sidebar group '{group}'")
self.get_sidebar_group_header(group).click()
self.wait(300)
return self
def get_sidebar_session_by_name(self, name: str) -> Locator:
"""Sidebar session row matched by its display name.
Scoped away from the All-Chats drawer by requiring the row to sit
under the sidebar group list (sibling of ``groupLabel`` buttons).
"""
return self.page.locator(
f'div[role="button"][class*="item"]:has-text("{name}")'
).first
# ========== Non-owner tab banner (upstream #5664) ==========
def get_queue_banner(self) -> Locator:
"""The queue-only info banner in the sender area (non-owner tab)."""
return self.page.locator(self.QUEUE_BANNER).filter(
has_text=self._QUEUE_BANNER_RE
).first
# ========== Model and Agent switching ==========
def open_model_selector(self) -> "ChatPage":
"""Open the model selector."""
logger.info("Opening model selector")
# The model selector lives in the right-side area of the header
header = self.page.locator('.qwenpaw-chat-anywhere-layout-right-header')
model_btn = header.locator(self.MODEL_SELECTOR).first
model_btn.click()
self.wait(500)
return self
def select_model(self, model_name: str) -> "ChatPage":
"""
Select a model.
Args:
model_name: model name
Returns:
self
"""
logger.info(f"Selecting model: {model_name}")
# Find and select the model
model_option = self.page.locator(self.MODEL_OPTION).filter(has_text=model_name).first
if model_option.count() > 0:
model_option.click()
self.wait(1000)
logger.info(f"Model selected: {model_name}")
return self
def get_available_models(self) -> List[str]:
"""Get the list of available models."""
options = self.page.locator(self.MODEL_OPTION).all()
models = [opt.inner_text() for opt in options]
return models
def open_agent_selector(self) -> "ChatPage":
"""Open the Agent selector."""
logger.info("Opening agent selector")
agent_btn = self.page.locator(self.AGENT_SELECTOR).first
if agent_btn.count() > 0:
agent_btn.click()
self.wait(500)
return self
# ========== Skill invocation ==========
def invoke_skill(self, skill_name: str, input_text: str = "") -> "ChatPage":
"""
Invoke a skill.
Args:
skill_name: skill name
input_text: input arguments
Returns:
self
"""
command = f"/{skill_name}"
if input_text:
command += f" {input_text}"
logger.info(f"Invoking skill: {command}")
return self.send_message_and_wait(command)
def get_skills_list(self) -> Optional[str]:
"""Get the skill list (via the /skills command)."""
self.send_message("/skills")
response = self.wait_for_ai_response()
if response:
return self.get_message_text(response)
return None
# ========== Tool details ==========
def expand_tool_details(self, message_index: int = -1) -> bool:
"""
Expand the tool invocation details.
Args:
message_index: message index (-1 means the last one)
Returns:
whether the expansion succeeded
"""
messages = self.get_ai_messages()
if not messages:
return False
target_msg = messages[message_index]
toggle_btn = target_msg.locator(self.TOOL_TOGGLE).first
if toggle_btn.count() > 0:
toggle_btn.click()
self.wait(500)
return self.assert_visible(self.TOOL_DETAILS, timeout=3000)
return False
# ========== Error handling ==========
def has_error(self) -> bool:
"""Check whether there is an error message."""
return self.assert_visible(self.ERROR_MESSAGE, timeout=2000)
def get_error_message(self) -> Optional[str]:
"""Get the error message text."""
error = self.find(self.ERROR_MESSAGE)
if error.count() > 0:
return error.inner_text()
return None
def dismiss_error(self) -> "ChatPage":
"""Dismiss the error message."""
error = self.find(self.ERROR_MESSAGE)
if error.count() > 0:
close_btn = error.locator('.qwenpaw-message-close, .qwenpaw-notification-close').first
if close_btn.count() > 0:
close_btn.click()
self.wait(500)
return self
# ========== Scrolling and navigation ==========
def scroll_to_top(self) -> "ChatPage":
"""Scroll the message list to the top."""
self.page.evaluate("""() => {
const list = document.querySelector('.qwenpaw-bubble-list-scroll');
if (list) list.scrollTop = 0;
}""")
self.wait(500)
return self
def scroll_to_bottom(self) -> "ChatPage":
"""Scroll the message list to the bottom."""
self.page.evaluate("""() => {
const list = document.querySelector('.qwenpaw-bubble-list-scroll');
if (list) list.scrollTop = list.scrollHeight;
}""")
self.wait(500)
return self
def scroll_to_message(self, message_index: int) -> "ChatPage":
"""
Scroll to the message at the given index.
Args:
message_index: message index
Returns:
self
"""
messages = self.get_all_messages()
if messages and message_index < len(messages):
messages[message_index].scroll_into_view_if_needed()
self.wait(500)
return self
# ========== Composite actions ==========
def complete_chat_flow(self, messages: List[str]) -> "ChatPage":
"""
Run a complete chat flow.
Args:
messages: list of messages to send
Returns:
self
"""
logger.info(f"Starting chat flow with {len(messages)} messages")
for msg in messages:
self.send_message_and_wait(msg)
logger.info("Chat flow completed")
return self
def create_chat_and_send(self, message: str) -> "ChatPage":
"""
Create a new chat and send a message.
Args:
message: message content
Returns:
self
"""
return self.create_new_chat().send_message_and_wait(message)
# ========== Cleanup ==========
def delete_all_sessions(self, max_attempts: int = 50) -> "ChatPage":
"""
Delete all sessions; used to clean up test data after the test.
WARNING: cleanup is robustness-sensitive; the previous test may have left the page in any abnormal state
(popups not closed, menus not collapsed, focus stuck in the input box, jittering popovers, etc.). Before opening
the session list, force-reset the page state to avoid 60s dead waits caused by occlusion.
"""
logger.info("Cleaning up: deleting all sessions")
# ===== State self-healing: restore the page to a stable operable state =====
try:
# Press Escape several times to close popups, dropdowns, modals, etc.
for _ in range(3):
self.page.keyboard.press("Escape")
self.wait(100)
# Move the mouse to the corner to avoid any hover popover occluding the buttons
self.page.mouse.move(0, 0)
# Scroll to the top of the page to make sure the sidebar button is visible
try:
self.page.evaluate("() => window.scrollTo(0, 0)")
except Exception:
pass
self.wait(300)
except Exception as e:
logger.warning(f"[cleanup] page state reset partially failed: {e}")
try:
self.open_session_list()
except Exception as e:
logger.warning(f"[cleanup] open_session_list failed, skip cleanup: {e}")
return self
deleted_count = 0
for _ in range(max_attempts):
try:
session_count = self.get_session_count()
except Exception as e:
logger.warning(f"[cleanup] get_session_count failed: {e}")
break
if session_count == 0:
break
try:
self.delete_session(0)
deleted_count += 1
except Exception as error:
logger.warning(f"Failed to delete session: {error}")
break
logger.info(f"Cleanup complete: deleted {deleted_count} sessions")
return self