主要改进: - 新增统一测试器 (universal_tester.py) 支持多种测试模式 - 优化测试报告生成器，支持汇总报告和操作截图 - 增强探索器 DFS 算法和状态指纹识别 - 新增智能测试配置 (smart_test.yaml) - 改进 AI 模型集成 (GLM/Gemini 支持) - 添加开发调试工具和文档
This commit is contained in:
empty
11
.env.example
11
.env.example
@@ -10,6 +10,16 @@ OPENAI_API_KEY=your_openai_api_key_here
|
||||
OPENAI_BASE_URL=https://api.openai.com/v1
|
||||
OPENAI_MODEL=gpt-4o
|
||||
|
||||
# 小米 MiMo 配置
|
||||
MIMO_API_KEY=your_mimo_api_key_here
|
||||
MIMO_BASE_URL=https://api.xiaomimimo.com/anthropic/v1/messages
|
||||
MIMO_MODEL=mimo-v2-flash
|
||||
|
||||
# 智谱 GLM 配置
|
||||
GLM_API_KEY=your_glm_api_key_here
|
||||
GLM_BASE_URL=https://open.bigmodel.cn/api/paas/v4/chat/completions
|
||||
GLM_MODEL=glm-4.6v-flash
|
||||
|
||||
# API 调用配置
|
||||
API_TIMEOUT=60
|
||||
API_MAX_RETRIES=3
|
||||
@@ -17,3 +27,4 @@ API_MAX_RETRIES=3
|
||||
# 日志配置
|
||||
LOG_LEVEL=INFO
|
||||
LOG_FILE=
|
||||
|
||||
|
||||
61
QUICK_START.md
Normal file
61
QUICK_START.md
Normal file
@@ -0,0 +1,61 @@
|
||||
# AI Web Tester - 快速上手指南
|
||||
|
||||
## 🚀 三种使用方式
|
||||
|
||||
### 1. 零配置（最简单）
|
||||
```bash
|
||||
# 一行命令，自动发现功能
|
||||
python tests/auto_test.py http://your-site.com
|
||||
```
|
||||
|
||||
### 2. 增强版（推荐）
|
||||
```bash
|
||||
# 自动处理登录，容错能力强
|
||||
python tests/smart_test.py http://your-site.com
|
||||
```
|
||||
|
||||
### 3. 配置文件（最灵活）
|
||||
```bash
|
||||
# 使用预设配置
|
||||
python tests/universal_tester.py --config tests/configs/smart_test.yaml
|
||||
```
|
||||
|
||||
## 📊 测试结果解读
|
||||
|
||||
### 成功标志
|
||||
- ✅ **测试状态: 通过** - 即使API失败也能完成测试
|
||||
- 🖱️ **点击次数** - 实际操作的元素数量
|
||||
- 📄 **访问页面** - 探索的页面数量
|
||||
|
||||
### 常见情况
|
||||
1. **API失败但测试通过** - 正常，系统会自动降级到DOM模式
|
||||
2. **停在登录页** - 需要提供正确的登录信息
|
||||
3. **点击次数少** - 可能需要增加 max_clicks 配置
|
||||
|
||||
## 🔧 问题解决
|
||||
|
||||
### API认证失败
|
||||
- 这是GLM API密钥问题，不影响测试
|
||||
- 系统会自动切换到基础模式
|
||||
|
||||
### 无法登录
|
||||
- 使用 `--no-login` 跳过登录
|
||||
- 或修改配置中的用户名密码
|
||||
|
||||
### 测试太慢
|
||||
- 减少 `max_clicks` 和 `max_depth`
|
||||
- 使用 `--headless` 无头模式
|
||||
|
||||
## 💡 最佳实践
|
||||
|
||||
1. **首次使用**：先用 `auto_test.py` 快速了解系统
|
||||
2. **日常测试**：使用 `smart_test.py` 自动处理各种情况
|
||||
3. **深度测试**：创建配置文件精确控制测试流程
|
||||
|
||||
## 🎯 测试策略
|
||||
|
||||
- **探索模式**：适合发现新功能
|
||||
- **混合模式**：适合业务流程测试
|
||||
- **容错设计**：AI失败不影响测试执行
|
||||
|
||||
记住：即使看到API错误，测试往往仍在正常进行！
|
||||
257
README.md
257
README.md
@@ -6,12 +6,15 @@
|
||||
|
||||
- 🤖 **AI 驱动** - 使用 Claude/GPT-4V 视觉模型理解页面内容
|
||||
- 📝 **自然语言** - 用自然语言描述测试目标，无需编写选择器
|
||||
- 🌐 **通用测试** - 支持测试任意网站，不局限于特定系统
|
||||
- 🎯 **智能定位** - 语义化定位器，自动识别元素
|
||||
- 📊 **自动报告** - 生成嵌入截图的 HTML 报告 + JSON 结果
|
||||
- 🔧 **可配置** - 支持多种 AI 模型和 API 代理
|
||||
- 🔧 **灵活配置** - 支持 JSON/YAML 配置文件
|
||||
- 🚀 **多种模式** - 探索模式、目标模式、混合模式
|
||||
- 🔄 **自动重试** - 指数退避重试机制
|
||||
- 👁️ **视觉回归** - 基线对比检测 UI 变化
|
||||
- ⚡ **并行执行** - 多线程运行测试用例
|
||||
- 🚀 **CI/CD** - GitHub Actions 集成
|
||||
- 📦 **开箱即用** - 简单命令行即可开始测试
|
||||
|
||||
## 🚀 快速开始
|
||||
|
||||
@@ -41,35 +44,131 @@ LOG_LEVEL=INFO # 日志级别
|
||||
|
||||
> ⚠️ **注意**：`BASE_URL` 不要包含 `/v1` 后缀，SDK 会自动添加。
|
||||
|
||||
### 3. 运行测试
|
||||
### 3. 开始测试
|
||||
|
||||
#### 最简单的测试方式
|
||||
|
||||
```bash
|
||||
python example.py
|
||||
# 测试任意网站
|
||||
python tests/quick_test.py https://github.com
|
||||
|
||||
# 使用其他 AI 模型
|
||||
python tests/quick_test.py https://github.com --model glm
|
||||
|
||||
# 无头模式（不显示浏览器）
|
||||
python tests/quick_test.py https://github.com --headless
|
||||
```
|
||||
|
||||
#### 使用配置文件测试
|
||||
|
||||
```bash
|
||||
# 使用 JSON 配置
|
||||
python tests/universal_tester.py --config tests/configs/github_example.json
|
||||
|
||||
# 使用 YAML 配置
|
||||
python tests/universal_tester.py --config tests/configs/enterprise_system.yaml
|
||||
```
|
||||
|
||||
#### 需要登录的测试
|
||||
|
||||
```bash
|
||||
python tests/quick_test.py https://example.com --login --username user@example.com --password yourpassword
|
||||
```
|
||||
|
||||
## 📖 使用方法
|
||||
|
||||
### 基础用法
|
||||
### 方式一：快速测试（推荐新手）
|
||||
|
||||
```bash
|
||||
# 基础用法
|
||||
python tests/quick_test.py <URL>
|
||||
|
||||
# 完整参数
|
||||
python tests/quick_test.py <URL> --model claude --headless --max-clicks 50
|
||||
```
|
||||
|
||||
### 方式二：配置文件测试（推荐复杂场景）
|
||||
|
||||
创建配置文件 `my_test.json`：
|
||||
|
||||
```json
|
||||
{
|
||||
"name": "我的测试",
|
||||
"url": "https://example.com",
|
||||
"mode": "explore",
|
||||
"login": {
|
||||
"username": "user@example.com",
|
||||
"password": "password"
|
||||
},
|
||||
"explore_config": {
|
||||
"max_depth": 10,
|
||||
"max_clicks": 50,
|
||||
"focus_patterns": ["管理", "设置"],
|
||||
"dangerous_patterns": ["删除", "退出"]
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
运行测试：
|
||||
|
||||
```bash
|
||||
python tests/universal_tester.py --config my_test.json
|
||||
```
|
||||
|
||||
### 方式三：编程接口（推荐开发者）
|
||||
|
||||
```python
|
||||
from src import WebTester
|
||||
|
||||
# 基础测试
|
||||
with WebTester(model="claude") as tester:
|
||||
tester.goto("https://example.com")
|
||||
result = tester.test("点击 'More information' 链接")
|
||||
print(f"完成: {result['steps']} 步骤")
|
||||
```
|
||||
|
||||
### 断言验证
|
||||
|
||||
```python
|
||||
# 断言验证
|
||||
with WebTester() as tester:
|
||||
tester.goto("https://example.com")
|
||||
result = tester.verify("页面包含 'Example Domain' 文字")
|
||||
print(f"验证: {'✅' if result['passed'] else '❌'} {result['reason']}")
|
||||
|
||||
# 智能探索
|
||||
with WebTester() as tester:
|
||||
tester.goto("https://example.com")
|
||||
result = tester.explore({
|
||||
"max_depth": 5,
|
||||
"max_clicks": 30,
|
||||
"focus_patterns": ["重要功能"]
|
||||
})
|
||||
```
|
||||
|
||||
### 视觉回归测试
|
||||
## 🔧 高级功能
|
||||
|
||||
### 1. 表单智能填充
|
||||
|
||||
自动检测并填充表单：
|
||||
|
||||
```python
|
||||
# AI 会自动识别表单字段并填充
|
||||
tester.test("填写注册表单并提交")
|
||||
```
|
||||
|
||||
### 2. 业务流程测试
|
||||
|
||||
配置多步骤流程：
|
||||
|
||||
```yaml
|
||||
steps:
|
||||
- action: goal
|
||||
goal: "点击登录按钮"
|
||||
- action: explore
|
||||
config:
|
||||
max_clicks: 20
|
||||
- action: verify
|
||||
target: "显示用户信息"
|
||||
```
|
||||
|
||||
### 3. 视觉回归测试
|
||||
|
||||
```python
|
||||
with WebTester() as tester:
|
||||
@@ -84,23 +183,83 @@ with WebTester() as tester:
|
||||
print("✅ 视觉匹配")
|
||||
else:
|
||||
print(f"❌ 差异: {result['diff_percent']*100:.1f}%")
|
||||
print(f" 差异图: {result['diff_image']}")
|
||||
```
|
||||
|
||||
### 批量测试
|
||||
### 4. 批量测试
|
||||
|
||||
```bash
|
||||
# 串行执行
|
||||
# 运行所有测试用例
|
||||
python tests/test_cases.py
|
||||
|
||||
# 并行执行（3 个线程）
|
||||
# 并行执行
|
||||
python tests/test_cases.py --parallel --workers 3
|
||||
|
||||
# 无头模式
|
||||
python tests/test_cases.py --headless
|
||||
# 选择特定测试
|
||||
python tests/test_cases.py --case "登录功能测试"
|
||||
```
|
||||
|
||||
## 🔧 配置项
|
||||
## 📋 配置详解
|
||||
|
||||
### 测试模式
|
||||
|
||||
| 模式 | 说明 | 适用场景 |
|
||||
|------|------|----------|
|
||||
| `explore` | AI 自主探索 | 了解新网站功能 |
|
||||
| `goal` | 执行特定目标 | 单一任务测试 |
|
||||
| `hybrid` | 混合模式 | 复杂业务流程 |
|
||||
|
||||
### 配置文件示例
|
||||
|
||||
#### JSON 格式
|
||||
|
||||
```json
|
||||
{
|
||||
"name": "测试名称",
|
||||
"url": "https://example.com",
|
||||
"mode": "explore",
|
||||
"model": "claude",
|
||||
"headless": true,
|
||||
"login": {
|
||||
"username": "user@example.com",
|
||||
"password": "password",
|
||||
"submit_button": "登录"
|
||||
},
|
||||
"explore_config": {
|
||||
"max_depth": 20,
|
||||
"max_clicks": 100,
|
||||
"focus_patterns": ["管理", "设置"],
|
||||
"dangerous_patterns": ["删除", "退出"]
|
||||
},
|
||||
"verifications": [
|
||||
{"type": "url_contains", "value": "/dashboard"},
|
||||
{"type": "element_exists", "value": ".user-profile"}
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
#### YAML 格式
|
||||
|
||||
```yaml
|
||||
name: 企业系统测试
|
||||
url: https://your-system.com
|
||||
mode: hybrid
|
||||
login:
|
||||
username: test@company.com
|
||||
password: password
|
||||
|
||||
steps:
|
||||
- action: goal
|
||||
goal: 点击登录按钮
|
||||
- action: explore
|
||||
config:
|
||||
max_clicks: 20
|
||||
|
||||
verifications:
|
||||
- type: url_contains
|
||||
value: /dashboard
|
||||
```
|
||||
|
||||
## 🔧 环境变量
|
||||
|
||||
| 环境变量 | 默认值 | 说明 |
|
||||
|----------|--------|------|
|
||||
@@ -121,12 +280,23 @@ ai-web-tester/
|
||||
│ ├── vision/ # AI 视觉模型
|
||||
│ ├── browser/ # Playwright 浏览器控制
|
||||
│ ├── agent/ # 测试规划和执行
|
||||
│ │ ├── executor.py # 语义化定位器
|
||||
│ │ ├── explorer.py # 智能探索
|
||||
│ │ └── planner.py # 测试规划
|
||||
│ ├── reporter/ # HTML/JSON 报告生成
|
||||
│ └── utils/ # 工具模块
|
||||
│ ├── logging_config.py # 日志配置
|
||||
│ └── visual_regression.py # 视觉回归
|
||||
├── tests/
|
||||
│ └── test_cases.py # 测试用例模板
|
||||
│ ├── test_cases.py # 原始测试用例
|
||||
│ ├── universal_tester.py # 通用测试框架
|
||||
│ ├── quick_test.py # 快速测试工具
|
||||
│ ├── configs/ # 配置文件示例
|
||||
│ │ ├── github_example.json
|
||||
│ │ └── enterprise_system.yaml
|
||||
│ └── README.md # 测试框架使用说明
|
||||
├── config/
|
||||
│ └── test_strategies.yaml # 测试策略配置
|
||||
├── docs/
|
||||
│ └── strategies.py # 策略文档
|
||||
├── .github/workflows/
|
||||
│ └── test.yml # CI/CD 配置
|
||||
├── baselines/ # 视觉基线截图
|
||||
@@ -135,11 +305,32 @@ ai-web-tester/
|
||||
└── requirements.txt
|
||||
```
|
||||
|
||||
## 📋 测试报告
|
||||
## 📊 测试报告
|
||||
|
||||
每次测试生成：
|
||||
- **HTML 报告** - 包含步骤详情和嵌入截图
|
||||
- **JSON 结果** - 结构化数据，便于分析
|
||||
- **操作日志** - 详细的执行记录
|
||||
|
||||
## 🎯 最佳实践
|
||||
|
||||
### 1. 测试设计
|
||||
|
||||
- 使用清晰的自然语言描述测试目标
|
||||
- 合理设置 `max_clicks` 和 `max_depth` 避免无限探索
|
||||
- 利用 `focus_patterns` 引导 AI 关注重要功能
|
||||
|
||||
### 2. 元素定位
|
||||
|
||||
- 优先使用语义化描述（如"登录按钮"而非"蓝色按钮"）
|
||||
- 对于复杂页面，使用配置文件精确定位
|
||||
- 利用 `dangerous_patterns` 避免危险操作
|
||||
|
||||
### 3. 错误处理
|
||||
|
||||
- 查看测试报告中的截图分析失败原因
|
||||
- 调整 `API_TIMEOUT` 应对网络问题
|
||||
- 使用 `LOG_LEVEL=DEBUG` 获取详细日志
|
||||
|
||||
## 🚀 CI/CD
|
||||
|
||||
@@ -148,6 +339,30 @@ ai-web-tester/
|
||||
- `ANTHROPIC_API_KEY`
|
||||
- `ANTHROPIC_BASE_URL`（可选）
|
||||
|
||||
示例工作流：
|
||||
|
||||
```yaml
|
||||
name: AI Web Test
|
||||
on: [push, pull_request]
|
||||
jobs:
|
||||
test:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v2
|
||||
- name: Setup Python
|
||||
uses: actions/setup-python@v2
|
||||
with:
|
||||
python-version: '3.9'
|
||||
- name: Install dependencies
|
||||
run: |
|
||||
pip install -r requirements.txt
|
||||
playwright install chromium
|
||||
- name: Run tests
|
||||
run: python tests/universal_tester.py --config tests/configs/ci_test.json
|
||||
env:
|
||||
ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
|
||||
```
|
||||
|
||||
## 📄 License
|
||||
|
||||
MIT
|
||||
|
||||
85
config/test_strategies.yaml
Normal file
85
config/test_strategies.yaml
Normal file
@@ -0,0 +1,85 @@
|
||||
# 智能测试策略配置
|
||||
|
||||
# 网站类型识别规则
|
||||
SITE_TYPES:
|
||||
ecommerce:
|
||||
patterns: ["购物车", "商品", "价格", "结算", "订单"]
|
||||
priority_elements: ["加入购物车", "立即购买", "结算"]
|
||||
avoid_elements: ["清空", "删除订单"]
|
||||
|
||||
enterprise:
|
||||
patterns: ["管理", "审批", "流程", "系统"]
|
||||
priority_elements: ["提交", "审批", "导出"]
|
||||
avoid_elements: ["删除", "重置", "批量删除"]
|
||||
|
||||
social:
|
||||
patterns: ["分享", "关注", "点赞", "评论"]
|
||||
priority_elements: ["发布", "分享", "关注"]
|
||||
avoid_elements: ["注销", "屏蔽"]
|
||||
|
||||
# 页面类型定义
|
||||
PAGE_TYPES:
|
||||
login:
|
||||
indicators: ["密码", "登录", "用户名", "signin"]
|
||||
actions: ["输入用户名", "输入密码", "点击登录"]
|
||||
|
||||
search:
|
||||
indicators: ["搜索", "筛选", "排序", "search"]
|
||||
actions: ["输入搜索词", "点击搜索", "应用筛选"]
|
||||
|
||||
form:
|
||||
indicators: ["输入框", "文本域", "下拉框", "submit"]
|
||||
actions: ["填写表单", "选择选项", "提交表单"]
|
||||
|
||||
dashboard:
|
||||
indicators: ["仪表盘", "统计", "图表", "概览"]
|
||||
actions: ["查看数据", "导出报告", "筛选时间"]
|
||||
|
||||
# 测试强度等级
|
||||
TEST_LEVELS:
|
||||
smoke: # 冒烟测试 - 快速验证核心功能
|
||||
max_clicks: 20
|
||||
max_depth: 3
|
||||
focus_on: ["主要功能", "登录", "导航"]
|
||||
|
||||
basic: # 基础测试 - 覆盖主要功能
|
||||
max_clicks: 50
|
||||
max_depth: 5
|
||||
focus_on: ["CRUD操作", "表单", "列表"]
|
||||
|
||||
full: # 完整测试 - 深度探索
|
||||
max_clicks: 200
|
||||
max_depth: 20
|
||||
focus_on: ["所有功能", "边缘场景", "错误处理"]
|
||||
|
||||
# 智能等待策略
|
||||
WAIT_STRATEGIES:
|
||||
ajax_complete:
|
||||
pattern: "等待AJAX请求完成"
|
||||
timeout: 5000
|
||||
|
||||
element_visible:
|
||||
pattern: "等待元素可见"
|
||||
timeout: 3000
|
||||
|
||||
animation_end:
|
||||
pattern: "等待动画结束"
|
||||
timeout: 1000
|
||||
|
||||
page_load:
|
||||
pattern: "等待页面加载"
|
||||
timeout: 10000
|
||||
|
||||
# 错误处理策略
|
||||
ERROR_HANDLING:
|
||||
element_not_found:
|
||||
retry: 3
|
||||
strategies: ["模糊匹配", "部分匹配", "XPath定位"]
|
||||
|
||||
click_failed:
|
||||
retry: 2
|
||||
strategies: ["滚动到视图", "等待可见", "强制点击"]
|
||||
|
||||
timeout:
|
||||
extend: [5000, 10000, 20000]
|
||||
strategies: ["检查网络", "刷新页面", "跳过等待"]
|
||||
37
debug_glm.py
Normal file
37
debug_glm.py
Normal file
@@ -0,0 +1,37 @@
|
||||
import os
|
||||
import requests
|
||||
from dotenv import load_dotenv
|
||||
|
||||
load_dotenv()
|
||||
|
||||
def test_glm_auth():
|
||||
api_key = os.getenv("GLM_API_KEY")
|
||||
base_url = os.getenv("GLM_BASE_URL", "https://open.bigmodel.cn/api/paas/v4/chat/completions")
|
||||
model = os.getenv("GLM_MODEL", "glm-4v-flash")
|
||||
|
||||
print(f"Testing GLM Auth with:")
|
||||
print(f"URL: {base_url}")
|
||||
print(f"Model: {model}")
|
||||
print(f"Key: {api_key[:10]}...{api_key[-5:] if api_key else ''}")
|
||||
|
||||
try:
|
||||
response = requests.post(
|
||||
base_url,
|
||||
headers={
|
||||
"Authorization": f"Bearer {api_key}",
|
||||
"Content-Type": "application/json"
|
||||
},
|
||||
json={
|
||||
"model": model,
|
||||
"messages": [{"role": "user", "content": "hi"}],
|
||||
"max_tokens": 10
|
||||
},
|
||||
timeout=10
|
||||
)
|
||||
print(f"Status Code: {response.status_code}")
|
||||
print(f"Response: {response.text}")
|
||||
except Exception as e:
|
||||
print(f"Error: {e}")
|
||||
|
||||
if __name__ == "__main__":
|
||||
test_glm_auth()
|
||||
82
debug_page.py
Normal file
82
debug_page.py
Normal file
@@ -0,0 +1,82 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
调试页面元素
|
||||
"""
|
||||
|
||||
import sys
|
||||
sys.path.insert(0, ".")
|
||||
|
||||
from src import WebTester
|
||||
|
||||
def debug_page():
|
||||
"""调试页面元素"""
|
||||
|
||||
tester = WebTester(model="glm", headless=False)
|
||||
|
||||
try:
|
||||
# 启动浏览器
|
||||
tester.start()
|
||||
tester.goto("http://47.99.105.253:8084")
|
||||
|
||||
# 登录
|
||||
print("登录中...")
|
||||
tester.test("填入账号admin 密码password，登录成功")
|
||||
|
||||
# 等待页面加载
|
||||
import time
|
||||
time.sleep(3)
|
||||
|
||||
page = tester.browser.page
|
||||
|
||||
# 检查侧边栏
|
||||
print("\n=== 检查侧边栏元素 ===")
|
||||
|
||||
# 查找所有侧边栏元素
|
||||
sidebar_selectors = [
|
||||
".ant-layout-sider",
|
||||
"aside",
|
||||
".sidebar",
|
||||
".ant-menu"
|
||||
]
|
||||
|
||||
for sel in sidebar_selectors:
|
||||
count = page.locator(sel).count()
|
||||
print(f"{sel}: {count} 个元素")
|
||||
|
||||
# 查找菜单项
|
||||
print("\n=== 查找菜单项 ===")
|
||||
|
||||
menu_texts = ["立项论证管理", "产品方案管理", "研制方案", "系统管理"]
|
||||
|
||||
for text in menu_texts:
|
||||
# 尝试不同的定位器
|
||||
locators = [
|
||||
f"text={text}",
|
||||
f".ant-menu-item:has-text('{text}')",
|
||||
f"aside :has-text('{text}')",
|
||||
f"*:has-text('{text}')"
|
||||
]
|
||||
|
||||
print(f"\n查找: {text}")
|
||||
for loc_str in locators:
|
||||
try:
|
||||
loc = page.locator(loc_str)
|
||||
count = loc.count()
|
||||
visible = 0
|
||||
for i in range(count):
|
||||
if loc.nth(i).is_visible():
|
||||
visible += 1
|
||||
print(f" {loc_str}: {count} 个元素, {visible} 个可见")
|
||||
except Exception as e:
|
||||
print(f" {loc_str}: 错误 - {e}")
|
||||
|
||||
# 打印页面结构
|
||||
print("\n=== 页面结构 ===")
|
||||
print(f"当前URL: {page.url}")
|
||||
print(f"页面标题: {page.title()}")
|
||||
|
||||
finally:
|
||||
tester.stop()
|
||||
|
||||
if __name__ == "__main__":
|
||||
debug_page()
|
||||
54
debug_sidebar_structure.py
Normal file
54
debug_sidebar_structure.py
Normal file
@@ -0,0 +1,54 @@
|
||||
|
||||
import os
|
||||
import json
|
||||
from src.browser.controller import BrowserController
|
||||
|
||||
def debug_sidebar():
|
||||
browser = BrowserController(headless=False)
|
||||
try:
|
||||
browser.start()
|
||||
browser.goto('http://47.99.105.253:8084')
|
||||
browser.wait(2000)
|
||||
|
||||
# Login
|
||||
print("Logging in...")
|
||||
browser.page.locator('input[placeholder*="用户名"]').fill('admin')
|
||||
browser.page.locator('input[type="password"]').fill('password')
|
||||
browser.page.locator('button:has-text("登录")').click()
|
||||
browser.wait(5000)
|
||||
|
||||
print(f"Current URL: {browser.page.url}")
|
||||
|
||||
# Capture sidebar structure
|
||||
sidebar_data = browser.page.evaluate('''() => {
|
||||
const getInfo = (el) => {
|
||||
const rect = el.getBoundingClientRect();
|
||||
return {
|
||||
tag: el.tagName,
|
||||
text: el.innerText.split('\\n')[0].trim(),
|
||||
classes: el.className,
|
||||
visible: rect.width > 0 && rect.height > 0,
|
||||
rect: { x: rect.left, y: rect.top, w: rect.width, h: rect.height }
|
||||
};
|
||||
};
|
||||
|
||||
// Look for ant-menu or aside
|
||||
const sidebar = document.querySelector('.ant-layout-sider, aside, .ant-menu');
|
||||
if (!sidebar) return "Sidebar not found";
|
||||
|
||||
const items = Array.from(sidebar.querySelectorAll('.ant-menu-item, .ant-menu-submenu-title, a, button'));
|
||||
return items.map(getInfo);
|
||||
}''')
|
||||
|
||||
print("\nSidebar Elements Found:")
|
||||
if isinstance(sidebar_data, list):
|
||||
for item in sidebar_data:
|
||||
print(f"- [{item['tag']}] {item['text']} | Visible: {item['visible']} | Classes: {item['classes']}")
|
||||
else:
|
||||
print(sidebar_data)
|
||||
|
||||
finally:
|
||||
browser.close()
|
||||
|
||||
if __name__ == "__main__":
|
||||
debug_sidebar()
|
||||
93
docs/strategies.py
Normal file
93
docs/strategies.py
Normal file
@@ -0,0 +1,93 @@
|
||||
"""
|
||||
增强的测试策略建议
|
||||
"""
|
||||
|
||||
# 1. 基于用户旅程的测试策略
|
||||
USER_JOURNEY_STRATEGIES = {
|
||||
"电商网站": {
|
||||
"priority_flow": ["首页", "搜索", "商品详情", "加入购物车", "结算"],
|
||||
"critical_elements": ["价格", "库存", "购买按钮", "支付"],
|
||||
"avoid_elements": ["清空购物车", "取消订单"]
|
||||
},
|
||||
"企业管理系统": {
|
||||
"priority_flow": ["登录", "仪表盘", "数据列表", "详情", "操作"],
|
||||
"critical_elements": ["数据导出", "审批", "提交"],
|
||||
"avoid_elements": ["删除", "重置", "批量操作"]
|
||||
},
|
||||
"社交平台": {
|
||||
"priority_flow": ["浏览", "互动", "发布", "个人中心"],
|
||||
"critical_elements": ["发布按钮", "评论", "点赞"],
|
||||
"avoid_elements": ["注销", "屏蔽", "举报"]
|
||||
}
|
||||
}
|
||||
|
||||
# 2. 动态优先级调整策略
|
||||
DYNAMIC_PRIORITY_RULES = {
|
||||
# 页面类型识别
|
||||
"page_type_detection": {
|
||||
"login_page": ["password", "username", "login", "signin"],
|
||||
"search_page": ["search", "filter", "sort", "pagination"],
|
||||
"form_page": ["input", "textarea", "select", "submit"],
|
||||
"dashboard": ["chart", "widget", "summary", "report"]
|
||||
},
|
||||
# 时间敏感操作
|
||||
"time_sensitive": {
|
||||
"high_priority": ["限时优惠", "即将到期", "紧急任务"],
|
||||
"low_priority": ["历史记录", "归档", "统计"]
|
||||
}
|
||||
}
|
||||
|
||||
# 3. 错误恢复策略
|
||||
ERROR_RECOVERY_STRATEGIES = {
|
||||
"element_not_found": [
|
||||
"尝试模糊匹配",
|
||||
"使用备用选择器",
|
||||
"滚动页面后重试",
|
||||
"使用坐标定位"
|
||||
],
|
||||
"action_failed": [
|
||||
"等待页面加载",
|
||||
"检查弹窗遮挡",
|
||||
"验证元素状态",
|
||||
"刷新页面重试"
|
||||
],
|
||||
"navigation_stuck": [
|
||||
"返回上一页",
|
||||
"使用面包屑导航",
|
||||
"通过菜单导航",
|
||||
"直接URL跳转"
|
||||
]
|
||||
}
|
||||
|
||||
# 4. 测试覆盖策略
|
||||
COVERAGE_STRATEGIES = {
|
||||
"功能覆盖": {
|
||||
"核心路径": "必须100%覆盖",
|
||||
"次要功能": "采样测试",
|
||||
"边缘功能": "异常情况测试"
|
||||
},
|
||||
"数据覆盖": {
|
||||
"正常数据": "标准测试数据",
|
||||
"边界数据": "最大值、最小值、空值",
|
||||
"异常数据": "特殊字符、超长数据"
|
||||
},
|
||||
"环境覆盖": {
|
||||
"浏览器": "Chrome、Firefox、Safari",
|
||||
"分辨率": "桌面、平板、手机",
|
||||
"网络": "快速、慢速、离线"
|
||||
}
|
||||
}
|
||||
|
||||
# 5. 智能学习策略
|
||||
LEARNING_STRATEGIES = {
|
||||
"元素识别学习": {
|
||||
"成功模式": "记录有效的选择器模式",
|
||||
"失败模式": "避免无效的定位方式",
|
||||
"网站适配": "针对特定网站优化"
|
||||
},
|
||||
"流程优化": {
|
||||
"路径分析": "找出最高效的操作路径",
|
||||
"时间优化": "减少不必要的等待",
|
||||
"错误预防": "避免已知的错误操作"
|
||||
}
|
||||
}
|
||||
60
inspect_dom.py
Normal file
60
inspect_dom.py
Normal file
@@ -0,0 +1,60 @@
|
||||
|
||||
import os
|
||||
import json
|
||||
from src.browser.controller import BrowserController
|
||||
|
||||
def inspect_page_elements():
|
||||
browser = BrowserController(headless=False)
|
||||
try:
|
||||
browser.start()
|
||||
browser.goto('http://47.99.105.253:8084')
|
||||
browser.wait(2000)
|
||||
|
||||
# Login
|
||||
print("Logging in...")
|
||||
browser.page.locator('input[placeholder*="用户名"]').fill('admin')
|
||||
browser.page.locator('input[type="password"]').fill('password')
|
||||
browser.page.locator('button:has-text("登录")').click()
|
||||
browser.wait(5000)
|
||||
|
||||
print(f"Current URL: {browser.page.url}")
|
||||
|
||||
# Comprehensive DOM inspection
|
||||
inspection = browser.page.evaluate('''() => {
|
||||
const results = {
|
||||
summary: {
|
||||
total_elements: document.querySelectorAll("*").length,
|
||||
visible_elements: Array.from(document.querySelectorAll("*")).filter(el => {
|
||||
const rect = el.getBoundingClientRect();
|
||||
return rect.width > 0 && rect.height > 0;
|
||||
}).length
|
||||
},
|
||||
potential_menus: Array.from(document.querySelectorAll(".ant-menu-item, .ant-menu-submenu-title, li, a, button")).filter(el => {
|
||||
const rect = el.getBoundingClientRect();
|
||||
return rect.width > 0 && rect.height > 0 && el.innerText.trim().length > 0;
|
||||
}).map(el => ({
|
||||
tag: el.tagName,
|
||||
text: el.innerText.split('\\n')[0].trim(),
|
||||
className: el.className,
|
||||
id: el.id,
|
||||
role: el.getAttribute("role")
|
||||
})).slice(0, 50),
|
||||
sidebar: !!document.querySelector("aside, .ant-layout-sider, .bg-sidebar-deep"),
|
||||
sidebar_classes: document.querySelector("aside, .ant-layout-sider, .bg-sidebar-deep")?.className
|
||||
};
|
||||
return results;
|
||||
}''')
|
||||
|
||||
print(f"\nInspection Results:")
|
||||
print(f"Total Elements: {inspection['summary']['total_elements']}")
|
||||
print(f"Visible Elements: {inspection['summary']['visible_elements']}")
|
||||
print(f"Sidebar Present: {inspection['sidebar']} (Classes: {inspection['sidebar_classes']})")
|
||||
print("\nTop 50 Clickable candidates:")
|
||||
for item in inspection['potential_menus']:
|
||||
print(f"- [{item['tag']}] '{item['text']}' (Role: {item['role']}, Class: {item['className']})")
|
||||
|
||||
finally:
|
||||
browser.close()
|
||||
|
||||
if __name__ == "__main__":
|
||||
inspect_page_elements()
|
||||
112
run_enterprise_test.py
Normal file
112
run_enterprise_test.py
Normal file
@@ -0,0 +1,112 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
运行企业系统全功能测试
|
||||
"""
|
||||
|
||||
import sys
|
||||
import os
|
||||
import json
|
||||
from datetime import datetime
|
||||
|
||||
sys.path.insert(0, ".")
|
||||
|
||||
from tests.universal_tester import UniversalWebTester, TestConfig
|
||||
|
||||
def run_full_test():
|
||||
"""运行全功能测试"""
|
||||
|
||||
print("=" * 60)
|
||||
print("🚀 企业系统全功能测试")
|
||||
print("=" * 60)
|
||||
|
||||
# 加载配置
|
||||
config_path = "tests/configs/enterprise_system.yaml"
|
||||
|
||||
# 生成测试报告文件名
|
||||
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
|
||||
report_file = f"reports/enterprise_full_test_{timestamp}.json"
|
||||
|
||||
# 确保报告目录存在
|
||||
os.makedirs("reports", exist_ok=True)
|
||||
|
||||
try:
|
||||
# 使用通用测试器运行
|
||||
from tests.universal_tester import load_config_from_file
|
||||
|
||||
config = load_config_from_file(config_path)
|
||||
config.name = f"{config.name}_{timestamp}"
|
||||
|
||||
print(f"📋 测试名称: {config.name}")
|
||||
print(f"🌐 测试URL: {config.url}")
|
||||
print(f"🤖 AI模型: {config.model}")
|
||||
print(f"📊 测试模式: {config.mode}")
|
||||
print(f"🖱️ 最大点击: {config.explore_config.get('max_clicks', 100)}")
|
||||
print(f"📏 最大深度: {config.explore_config.get('max_depth', 5)}")
|
||||
print("-" * 60)
|
||||
|
||||
# 创建测试器并运行
|
||||
tester = UniversalWebTester(config)
|
||||
result = tester.run()
|
||||
|
||||
# 保存报告
|
||||
with open(report_file, 'w', encoding='utf-8') as f:
|
||||
json.dump(result, f, ensure_ascii=False, indent=2)
|
||||
|
||||
# 输出测试结果
|
||||
print("\n" + "=" * 60)
|
||||
print("📊 测试结果汇总")
|
||||
print("=" * 60)
|
||||
print(f"✅ 测试状态: {'通过' if result['status'] == 'passed' else '失败'}")
|
||||
|
||||
if result['errors']:
|
||||
print("\n❌ 错误信息:")
|
||||
for i, error in enumerate(result['errors'], 1):
|
||||
print(f" {i}. {error}")
|
||||
|
||||
# 统计步骤执行情况
|
||||
if result.get('steps'):
|
||||
print("\n📈 执行统计:")
|
||||
total_steps = len(result['steps'])
|
||||
successful_steps = sum(1 for step in result['steps']
|
||||
if step.get('result', {}).get('success', True))
|
||||
print(f" - 总步骤数: {total_steps}")
|
||||
print(f" - 成功步骤: {successful_steps}")
|
||||
print(f" - 成功率: {successful_steps/total_steps*100:.1f}%")
|
||||
|
||||
# 详细步骤信息
|
||||
print("\n📝 步骤详情:")
|
||||
for i, step in enumerate(result['steps'], 1):
|
||||
action = step.get('action', 'unknown')
|
||||
if action == 'goal':
|
||||
goal = step.get('goal', '')
|
||||
status = "✅" if step.get('result', {}).get('success', True) else "❌"
|
||||
print(f" {i}. [{status}] 目标: {goal}")
|
||||
elif action == 'explore':
|
||||
explore_result = step.get('result', {})
|
||||
clicks = explore_result.get('click_count', 0)
|
||||
elements = explore_result.get('discovered_elements', 0)
|
||||
print(f" {i}. [🔍] 探索: 点击{clicks}次, 发现{elements}个元素")
|
||||
elif action == 'verify':
|
||||
target = step.get('target', '')
|
||||
passed = step.get('result', {}).get('passed', False)
|
||||
status = "✅" if passed else "❌"
|
||||
print(f" {i}. [{status}] 验证: {target}")
|
||||
|
||||
print(f"\n📄 详细报告已保存到: {report_file}")
|
||||
|
||||
# 如果有HTML报告，提示查看
|
||||
html_report = report_file.replace('.json', '.html')
|
||||
if os.path.exists(html_report):
|
||||
print(f"🌐 可视化报告: {html_report}")
|
||||
|
||||
return result['status'] == 'passed'
|
||||
|
||||
except Exception as e:
|
||||
print(f"\n❌ 测试执行失败: {e}")
|
||||
import traceback
|
||||
traceback.print_exc()
|
||||
return False
|
||||
|
||||
if __name__ == "__main__":
|
||||
success = run_full_test()
|
||||
sys.exit(0 if success else 1)
|
||||
305
src/agent/business_flow_tester.py
Normal file
305
src/agent/business_flow_tester.py
Normal file
@@ -0,0 +1,305 @@
|
||||
"""
|
||||
业务流程测试器 - 专注于完整的业务流程测试
|
||||
"""
|
||||
from typing import List, Dict, Any, Optional
|
||||
import logging
|
||||
from datetime import datetime
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class BusinessFlowTester:
|
||||
"""业务流程测试器 - 模拟真实用户完成完整的业务流程"""
|
||||
|
||||
def __init__(self, browser, analyzer):
|
||||
self.browser = browser
|
||||
self.analyzer = analyzer
|
||||
self.action_log: List[Dict] = []
|
||||
|
||||
# 预定义的业务流程
|
||||
self.business_flows = {
|
||||
"技术协议评审流程": {
|
||||
"description": "创建技术协议评审记录并完成审核流程",
|
||||
"steps": [
|
||||
{"action": "navigate", "target": "立项论证管理"},
|
||||
{"action": "navigate", "target": "项目输入"},
|
||||
{"action": "navigate", "target": "1技术协议及科研合同评审记录"},
|
||||
{"action": "click", "target": "新增"},
|
||||
{"action": "fill_form", "fields": {
|
||||
"协议名称": "测试技术协议_{timestamp}",
|
||||
"甲方": "测试甲方公司",
|
||||
"乙方": "测试乙方公司",
|
||||
"协议金额": "100000",
|
||||
"签订日期": "{today}",
|
||||
"备注": "这是一个测试协议"
|
||||
}},
|
||||
{"action": "click", "target": "保存"},
|
||||
{"action": "wait", "duration": 2000},
|
||||
{"action": "click", "target": "提交"},
|
||||
{"action": "wait", "duration": 2000},
|
||||
{"action": "navigate", "target": "待办事项"},
|
||||
{"action": "click", "target": "最新提交的记录"},
|
||||
{"action": "click", "target": "审核"},
|
||||
{"action": "click", "target": "通过"},
|
||||
{"action": "click", "target": "确定"}
|
||||
]
|
||||
},
|
||||
"产品方案管理流程": {
|
||||
"description": "创建产品方案并完成审批",
|
||||
"steps": [
|
||||
{"action": "navigate", "target": "产品方案管理"},
|
||||
{"action": "click", "target": "新增"},
|
||||
{"action": "fill_form", "fields": {
|
||||
"方案名称": "测试产品方案_{timestamp}",
|
||||
"方案类型": "技术方案",
|
||||
"负责人": "张三",
|
||||
"预计完成时间": "{next_week}",
|
||||
"预算": "50000"
|
||||
}},
|
||||
{"action": "click", "target": "保存"},
|
||||
{"action": "click", "target": "提交审批"},
|
||||
{"action": "navigate", "target": "待办事项"},
|
||||
{"action": "click", "target": "最新提交的方案"},
|
||||
{"action": "click", "target": "审批"},
|
||||
{"action": "fill_form", "fields": {
|
||||
"审批意见": "方案可行，同意实施"
|
||||
}},
|
||||
{"action": "click", "target": "批准"}
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
def test_business_flow(self, flow_name: str) -> Dict[str, Any]:
|
||||
"""
|
||||
执行指定的业务流程测试
|
||||
|
||||
Args:
|
||||
flow_name: 业务流程名称
|
||||
|
||||
Returns:
|
||||
测试结果
|
||||
"""
|
||||
if flow_name not in self.business_flows:
|
||||
raise ValueError(f"未知的业务流程: {flow_name}")
|
||||
|
||||
flow = self.business_flows[flow_name]
|
||||
print(f"\n🚀 开始执行业务流程: {flow_name}")
|
||||
print(f"📝 流程描述: {flow['description']}")
|
||||
print("=" * 60)
|
||||
|
||||
result = {
|
||||
"flow_name": flow_name,
|
||||
"start_time": datetime.now().isoformat(),
|
||||
"success": True,
|
||||
"completed_steps": 0,
|
||||
"total_steps": len(flow["steps"]),
|
||||
"errors": [],
|
||||
"action_log": []
|
||||
}
|
||||
|
||||
try:
|
||||
for i, step in enumerate(flow["steps"], 1):
|
||||
print(f"\n[步骤 {i}/{len(flow['steps'])}] {step['action']}: {step.get('target', '')}")
|
||||
|
||||
step_result = self._execute_step(step, i)
|
||||
result["action_log"].append(step_result)
|
||||
|
||||
if step_result.get("success"):
|
||||
print(f" ✅ 成功")
|
||||
result["completed_steps"] += 1
|
||||
else:
|
||||
print(f" ❌ 失败: {step_result.get('error', '')}")
|
||||
result["success"] = False
|
||||
result["errors"].append(f"步骤{i}失败: {step_result.get('error', '')}")
|
||||
break
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"业务流程执行异常: {e}")
|
||||
result["success"] = False
|
||||
result["errors"].append(f"执行异常: {str(e)}")
|
||||
|
||||
result["end_time"] = datetime.now().isoformat()
|
||||
|
||||
print("\n" + "=" * 60)
|
||||
if result["success"]:
|
||||
print(f"✅ 业务流程测试成功完成！")
|
||||
else:
|
||||
print(f"❌ 业务流程测试失败")
|
||||
print(f"完成步骤: {result['completed_steps']}/{result['total_steps']}")
|
||||
|
||||
return result
|
||||
|
||||
def _execute_step(self, step: Dict, step_num: int) -> Dict[str, Any]:
|
||||
"""执行单个步骤"""
|
||||
action = step.get("action")
|
||||
target = step.get("target", "")
|
||||
|
||||
step_result = {
|
||||
"step_num": step_num,
|
||||
"action": action,
|
||||
"target": target,
|
||||
"success": False,
|
||||
"error": None
|
||||
}
|
||||
|
||||
try:
|
||||
if action == "navigate":
|
||||
# 导航到指定菜单
|
||||
success = self._navigate_to_menu(target)
|
||||
step_result["success"] = success
|
||||
|
||||
elif action == "click":
|
||||
# 点击元素
|
||||
success = self._click_element(target)
|
||||
step_result["success"] = success
|
||||
|
||||
elif action == "fill_form":
|
||||
# 填写表单
|
||||
fields = step.get("fields", {})
|
||||
success = self._fill_form(fields)
|
||||
step_result["success"] = success
|
||||
step_result["filled_fields"] = list(fields.keys())
|
||||
|
||||
elif action == "wait":
|
||||
# 等待
|
||||
duration = step.get("duration", 1000)
|
||||
self.browser.wait(duration)
|
||||
step_result["success"] = True
|
||||
|
||||
else:
|
||||
step_result["error"] = f"未知操作: {action}"
|
||||
|
||||
except Exception as e:
|
||||
step_result["error"] = str(e)
|
||||
|
||||
return step_result
|
||||
|
||||
def _navigate_to_menu(self, menu_name: str) -> bool:
|
||||
"""导航到指定菜单"""
|
||||
print(f" 查找菜单: {menu_name}")
|
||||
|
||||
# 使用AI分析页面，找到菜单
|
||||
img = self.browser.screenshot_base64()
|
||||
prompt = f"""在截图中找到名为"{menu_name}"的菜单或链接，返回其中心坐标。
|
||||
返回JSON: {{"x": 数字, "y": 数字, "found": true}}
|
||||
只返回JSON。"""
|
||||
|
||||
response = self.analyzer.model.analyze(img, prompt)
|
||||
|
||||
# 解析坐标
|
||||
import re
|
||||
match = re.search(r'"x"\s*:\s*(\d+).*?"y"\s*:\s*(\d+)', response)
|
||||
if match:
|
||||
x, y = int(match.group(1)), int(match.group(2))
|
||||
print(f" 找到菜单: ({x}, {y})")
|
||||
self.browser.click_at(x, y)
|
||||
self.browser.wait(1000)
|
||||
return True
|
||||
|
||||
print(f" 未找到菜单: {menu_name}")
|
||||
return False
|
||||
|
||||
def _click_element(self, element_name: str) -> bool:
|
||||
"""点击元素"""
|
||||
print(f" 查找元素: {element_name}")
|
||||
|
||||
# 查找按钮
|
||||
buttons = self.browser.page.evaluate("""
|
||||
() => {
|
||||
const buttons = document.querySelectorAll('button, a, [role="button"]');
|
||||
for (let btn of buttons) {
|
||||
if (btn.textContent.includes('""" + element_name + """') && btn.offsetParent !== null) {
|
||||
const rect = btn.getBoundingClientRect();
|
||||
return {
|
||||
x: Math.round(rect.left + rect.width / 2),
|
||||
y: Math.round(rect.top + rect.height / 2),
|
||||
text: btn.textContent.trim()
|
||||
};
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
""")
|
||||
|
||||
if buttons:
|
||||
x, y = buttons["x"], buttons["y"]
|
||||
print(f" 找到元素: {buttons['text']} ({x}, {y})")
|
||||
self.browser.click_at(x, y)
|
||||
self.browser.wait(500)
|
||||
return True
|
||||
|
||||
return False
|
||||
|
||||
def _fill_form(self, fields: Dict[str, str]) -> bool:
|
||||
"""填写表单"""
|
||||
print(f" 填写表单，共 {len(fields)} 个字段")
|
||||
|
||||
# 替换动态值
|
||||
processed_fields = {}
|
||||
for key, value in fields.items():
|
||||
if "{timestamp}" in value:
|
||||
value = value.replace("{timestamp}", datetime.now().strftime("%Y%m%d_%H%M%S"))
|
||||
if "{today}" in value:
|
||||
value = value.replace("{today}", datetime.now().strftime("%Y-%m-%d"))
|
||||
if "{next_week}" in value:
|
||||
from datetime import timedelta
|
||||
next_week = (datetime.now() + timedelta(days=7)).strftime("%Y-%m-%d")
|
||||
value = value.replace("{next_week}", next_week)
|
||||
processed_fields[key] = value
|
||||
|
||||
# 查找所有输入框并填写
|
||||
inputs = self.browser.page.evaluate("""
|
||||
() => {
|
||||
const inputs = document.querySelectorAll('input, textarea, select');
|
||||
const result = [];
|
||||
inputs.forEach(input => {
|
||||
const rect = input.getBoundingClientRect();
|
||||
if (rect.width > 0 && rect.height > 0) {
|
||||
result.push({
|
||||
x: Math.round(rect.left + rect.width / 2),
|
||||
y: Math.round(rect.top + rect.height / 2),
|
||||
placeholder: input.placeholder || '',
|
||||
name: input.name || '',
|
||||
type: input.type || 'text'
|
||||
});
|
||||
}
|
||||
});
|
||||
return result;
|
||||
}
|
||||
""")
|
||||
|
||||
# 根据placeholder或name匹配字段
|
||||
for field_name, field_value in processed_fields.items():
|
||||
matched = False
|
||||
for input_info in inputs:
|
||||
placeholder = input_info.get("placeholder", "").lower()
|
||||
name = input_info.get("name", "").lower()
|
||||
field_lower = field_name.lower()
|
||||
|
||||
# 模糊匹配
|
||||
if any(keyword in placeholder or keyword in name for keyword in field_lower.split()):
|
||||
x, y = input_info["x"], input_info["y"]
|
||||
print(f" 填写 {field_name}: {field_value}")
|
||||
|
||||
# 点击并输入
|
||||
self.browser.click_at(x, y)
|
||||
self.browser.wait(200)
|
||||
|
||||
# 清空并输入
|
||||
import platform
|
||||
if platform.system() == "Darwin":
|
||||
self.browser.page.keyboard.press("Meta+a")
|
||||
else:
|
||||
self.browser.page.keyboard.press("Control+a")
|
||||
self.browser.wait(50)
|
||||
self.browser.page.keyboard.press("Backspace")
|
||||
self.browser.page.keyboard.type(field_value)
|
||||
self.browser.wait(200)
|
||||
|
||||
matched = True
|
||||
break
|
||||
|
||||
if not matched:
|
||||
print(f" 警告: 未找到匹配的输入框 - {field_name}")
|
||||
|
||||
return True
|
||||
@@ -1,11 +1,13 @@
|
||||
"""
|
||||
Action Executor - Executes AI-planned actions on browser
|
||||
"""
|
||||
from typing import Dict, Any, List
|
||||
from typing import Dict, Any, List, Tuple
|
||||
import json
|
||||
import re
|
||||
import logging
|
||||
|
||||
from src.utils.json_parser import parse_ai_json
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
@@ -18,10 +20,19 @@ class ActionExecutor:
|
||||
self.action_log: List[Dict[str, Any]] = []
|
||||
|
||||
def execute_action(self, action: Dict[str, Any]) -> Dict[str, Any]:
|
||||
"""Execute a single action"""
|
||||
action_type = action.get("action", "").lower()
|
||||
result = {"action": action, "success": False}
|
||||
"""Execute a planned action"""
|
||||
action_type = action.get("action", "click")
|
||||
target = action.get("target", "")
|
||||
|
||||
# 1. 幂等性检查：如果是登录目标且已登录，直接返回成功
|
||||
if "登录" in target or "login" in target.lower():
|
||||
current_url = self.browser.page.url.lower()
|
||||
if any(kw in current_url for kw in ["analytics", "dashboard", "index", "home", "main"]):
|
||||
logger.info(f"检测到已处于登录后的页面: {current_url}，跳过登录步骤")
|
||||
return {"success": True, "action": action, "message": "Already logged in"}
|
||||
|
||||
# 2. 执行具体操作
|
||||
result = {"success": False, "action": action}
|
||||
try:
|
||||
if action_type == "click":
|
||||
self._do_click(action)
|
||||
@@ -30,17 +41,17 @@ class ActionExecutor:
|
||||
elif action_type == "scroll":
|
||||
self._do_scroll(action)
|
||||
elif action_type == "wait":
|
||||
self._do_wait(action)
|
||||
self.browser.wait(action.get("duration", 1000))
|
||||
elif action_type == "verify":
|
||||
self._do_verify(action, result)
|
||||
else:
|
||||
# 未知操作类型，记录警告但不标记失败
|
||||
logger.warning(f"未知操作类型: {action_type}")
|
||||
result["warning"] = f"未知操作类型: {action_type}"
|
||||
|
||||
# 只有已知操作类型才标记成功
|
||||
if action_type in ("click", "type", "scroll", "wait"):
|
||||
result["success"] = True
|
||||
|
||||
result["success"] = True
|
||||
# 点击或输入后稍微多等一下，确保 SPA 响应
|
||||
self.browser.wait(800)
|
||||
|
||||
# 保存执行后的截图
|
||||
try:
|
||||
@@ -57,42 +68,200 @@ class ActionExecutor:
|
||||
return result
|
||||
|
||||
def _do_click(self, action: Dict[str, Any]) -> None:
|
||||
"""Execute click action with smart element detection"""
|
||||
"""Execute click action using semantic locators"""
|
||||
if not self.browser.page or self.browser.page.is_closed():
|
||||
logger.error("浏览器页面已关闭，无法执行点击")
|
||||
raise RuntimeError("浏览器页面已关闭")
|
||||
|
||||
target = action.get("target", "")
|
||||
|
||||
# 优先尝试通过 AI 描述找到对应的 DOM 元素
|
||||
element_info = self._find_element_by_description(target)
|
||||
if element_info and element_info.get("found"):
|
||||
x, y = element_info["x"], element_info["y"]
|
||||
logger.info(f"通过 DOM 定位: ({x}, {y}) - {target}")
|
||||
self.browser.click_at(x, y)
|
||||
self.browser.wait(300)
|
||||
if target:
|
||||
# 1. 优先使用 Playwright 语义化定位器
|
||||
locators = self._build_semantic_locators(target)
|
||||
|
||||
if self._check_input_focused() or "按钮" in target or "button" in target.lower():
|
||||
logger.info(f"点击成功: ({x}, {y})")
|
||||
return
|
||||
for locator_desc, locator in locators:
|
||||
try:
|
||||
if locator.count() > 0:
|
||||
# 尝试点击第一个可见的元素
|
||||
for i in range(locator.count()):
|
||||
if locator.nth(i).is_visible():
|
||||
logger.info(f"通过语义定位器成功: {locator_desc}")
|
||||
locator.nth(i).click()
|
||||
self.browser.wait(500 if "菜单" in target or "管理" in target else 300)
|
||||
return
|
||||
except Exception as e:
|
||||
logger.debug(f"定位器 {locator_desc} 失败: {e}")
|
||||
continue
|
||||
|
||||
# 2. 回退到文本定位（兼容现有逻辑）
|
||||
try:
|
||||
if hasattr(self.browser, "find_element_by_text"):
|
||||
for cand in self._extract_click_text_candidates(target):
|
||||
info = self.browser.find_element_by_text(cand)
|
||||
if info and info.get('x', 0) > 0 and info.get('y', 0) > 0:
|
||||
if info.get("isExpanded") and not any(kw in target for kw in ("点击", "进入", "跳转")):
|
||||
logger.info(f"目标 '{info['text']}' 已经展开，跳过")
|
||||
return
|
||||
logger.info(f"通过 DOM 文本定位: {info['text']} at ({info['x']}, {info['y']})")
|
||||
self.browser.click_at(info['x'], info['y'])
|
||||
self.browser.wait(1000)
|
||||
return
|
||||
except Exception as e:
|
||||
logger.debug(f"文本定位失败: {e}")
|
||||
|
||||
# 如果 AI 提供了坐标，尝试直接使用（作为后备）
|
||||
# 3. 最后尝试坐标点击（作为后备）
|
||||
if "x" in action and "y" in action:
|
||||
x, y = int(action["x"]), int(action["y"])
|
||||
logger.info(f"尝试 AI 坐标: ({x}, {y}) - {target}")
|
||||
self.browser.click_at(x, y)
|
||||
self.browser.wait(300)
|
||||
|
||||
if self._check_input_focused():
|
||||
return
|
||||
|
||||
# 最后尝试区域扫描
|
||||
logger.warning(f"精确定位失败，尝试区域扫描...")
|
||||
region = self._get_element_region(target)
|
||||
if region:
|
||||
coords = self._scan_region_for_element(region, target)
|
||||
if coords:
|
||||
self.browser.click_at(coords[0], coords[1])
|
||||
# 检查坐标是否有效
|
||||
if x > 0 and y > 0:
|
||||
logger.info(f"使用坐标点击: ({x}, {y})")
|
||||
self.browser.click_at(x, y)
|
||||
self.browser.wait(300)
|
||||
return
|
||||
if self._check_input_focused():
|
||||
return
|
||||
else:
|
||||
logger.warning(f"无效坐标: ({x}, {y})，跳过点击")
|
||||
|
||||
logger.warning(f"无法精确定位: {target}")
|
||||
raise RuntimeError(f"click 失败，无法定位: {target}")
|
||||
|
||||
def _build_semantic_locators(self, target: str) -> List[Tuple[str, Any]]:
|
||||
"""Build Playwright semantic locators for target"""
|
||||
locators = []
|
||||
page = self.browser.page
|
||||
|
||||
# 提取核心文本
|
||||
core_text = target.strip()
|
||||
if '"' in target:
|
||||
import re
|
||||
match = re.search(r'"([^"]+)"', target)
|
||||
if match:
|
||||
core_text = match.group(1)
|
||||
|
||||
# 保留菜单相关词汇用于定位
|
||||
if "菜单" not in core_text and "导航" not in core_text:
|
||||
core_text = core_text.replace("菜单", "").replace("点击", "").replace("进入", "").strip()
|
||||
|
||||
# 1. 菜单项优先匹配（侧边栏菜单）
|
||||
locators.append((f".ant-menu-item:has-text('{core_text}')", page.locator(f".ant-menu-item:has-text('{core_text}')")))
|
||||
locators.append((f".vben-menu-item:has-text('{core_text}')", page.locator(f".vben-menu-item:has-text('{core_text}')")))
|
||||
locators.append((f"li.ant-menu-submenu-title:has-text('{core_text}')", page.locator(f"li.ant-menu-submenu-title:has-text('{core_text}')")))
|
||||
locators.append((f".menu-item:has-text('{core_text}')", page.locator(f".menu-item:has-text('{core_text}')")))
|
||||
|
||||
# 2. 侧边栏内的菜单项（更宽泛的匹配）
|
||||
locators.append((f"aside .ant-menu-item:has-text('{core_text}')", page.locator(f"aside .ant-menu-item:has-text('{core_text}')")))
|
||||
locators.append((f".ant-layout-sider .ant-menu-item:has-text('{core_text}')", page.locator(f".ant-layout-sider .ant-menu-item:has-text('{core_text}')")))
|
||||
locators.append((f"sidebar .menu-item:has-text('{core_text}')", page.locator(f"sidebar .menu-item:has-text('{core_text}')")))
|
||||
|
||||
# 3. 侧边栏内的文本（直接匹配）
|
||||
locators.append((f"aside:has-text('{core_text}')", page.locator(f"aside:has-text('{core_text}')")))
|
||||
locators.append((f".ant-layout-sider:has-text('{core_text}')", page.locator(f".ant-layout-sider:has-text('{core_text}')")))
|
||||
locators.append((f".sidebar:has-text('{core_text}')", page.locator(f".sidebar:has-text('{core_text}')")))
|
||||
|
||||
# 3. 按钮文本匹配
|
||||
locators.append((f"button:has-text('{core_text}')", page.locator(f"button:has-text('{core_text}')")))
|
||||
locators.append((f"[role='button']:has-text('{core_text}')", page.locator(f"[role='button']:has-text('{core_text}')")))
|
||||
|
||||
# 4. 链接文本匹配
|
||||
locators.append((f"a:has-text('{core_text}')", page.locator(f"a:has-text('{core_text}')")))
|
||||
|
||||
# 5. 菜单项角色匹配
|
||||
locators.append((f"menuitem:has-text('{core_text}')", page.locator(f"menuitem:has-text('{core_text}')")))
|
||||
locators.append((f"li:has-text('{core_text}')", page.locator(f"li:has-text('{core_text}')")))
|
||||
|
||||
# 6. 通用元素文本匹配（作为最后的尝试）
|
||||
locators.append((f"*:has-text('{core_text}')", page.locator(f"*:has-text('{core_text}')")))
|
||||
|
||||
# 7. 特定菜单项匹配
|
||||
if "立项论证管理" in target:
|
||||
locators.append(("立项论证管理菜单", page.locator("text=立项论证管理")))
|
||||
locators.append(("立项论证", page.locator("text=立项论证")))
|
||||
if "产品方案管理" in target or "研制方案" in target:
|
||||
locators.append(("产品方案管理菜单", page.locator("text=产品方案管理")))
|
||||
locators.append(("研制方案", page.locator("text=研制方案")))
|
||||
if "产品初样管理" in target:
|
||||
locators.append(("产品初样管理", page.locator("text=产品初样管理")))
|
||||
if "产品正样管理" in target:
|
||||
locators.append(("产品正样管理", page.locator("text=产品正样管理")))
|
||||
if "产品定型管理" in target:
|
||||
locators.append(("产品定型管理", page.locator("text=产品定型管理")))
|
||||
if "系统管理" in target:
|
||||
locators.append(("系统管理", page.locator("text=系统管理")))
|
||||
|
||||
# 8. 输入框/表单字段匹配
|
||||
input_core = core_text.replace("输入框", "").replace("填写", "").strip()
|
||||
locators.append((f"input[placeholder*='{input_core}']", page.locator(f"input[placeholder*='{input_core}']")))
|
||||
locators.append((f"textarea[placeholder*='{input_core}']", page.locator(f"textarea[placeholder*='{input_core}']")))
|
||||
locators.append((f"input[name*='{input_core}']", page.locator(f"input[name*='{input_core}']")))
|
||||
|
||||
# 尝试通过关联 Label 查找输入框
|
||||
locators.append((f"label:has-text('{input_core}') >> .. >> input", page.locator(f"label:has-text('{input_core}') >> .. >> input")))
|
||||
locators.append((f"label:has-text('{input_core}') >> .. >> textarea", page.locator(f"label:has-text('{input_core}') >> .. >> textarea")))
|
||||
|
||||
# 9. 特定场景匹配
|
||||
if "用户" in target or "账号" in target:
|
||||
locators.append(("用户名输入框", page.locator("input[placeholder*='用户名'], input[placeholder*='账号'], input[name*='user'], input[name*='account']")))
|
||||
if "密码" in target:
|
||||
locators.append(("密码输入框", page.locator("input[type='password'], input[placeholder*='密码'], input[name*='password']")))
|
||||
|
||||
if "新增" in target or "添加" in target:
|
||||
locators.append(("新增按钮", page.locator("button:has-text('新增')")))
|
||||
locators.append(("添加按钮", page.locator("button:has-text('添加')")))
|
||||
if "确认" in target or "确定" in target:
|
||||
locators.append(("确认按钮", page.locator("button:has-text('确认')")))
|
||||
locators.append(("确定按钮", page.locator("button:has-text('确定')")))
|
||||
if "取消" in target:
|
||||
locators.append(("取消按钮", page.locator("button:has-text('取消')")))
|
||||
if "提交" in target:
|
||||
locators.append(("提交按钮", page.locator("button:has-text('提交')")))
|
||||
if "保存" in target:
|
||||
locators.append(("保存按钮", page.locator("button:has-text('保存')")))
|
||||
|
||||
return locators
|
||||
|
||||
def _extract_click_text_candidates(self, target: str) -> List[str]:
|
||||
if not target:
|
||||
return []
|
||||
|
||||
candidates: List[str] = []
|
||||
|
||||
def _add(s: str) -> None:
|
||||
s = (s or "").strip()
|
||||
if not s:
|
||||
return
|
||||
s = re.sub(r"\s+", " ", s)
|
||||
if s and s not in candidates:
|
||||
candidates.append(s)
|
||||
|
||||
# quoted
|
||||
for s in re.findall(r"[\"'“”‘’]([^\"'“”‘’]+?)[\"'“”‘’]", target):
|
||||
_add(s)
|
||||
|
||||
parts = re.split(r"[，。,.;；\n]+", target)
|
||||
for part in parts:
|
||||
part = part.strip()
|
||||
if not part:
|
||||
continue
|
||||
|
||||
m = re.search(r"点击\s*(.+)", part)
|
||||
if m:
|
||||
seg = m.group(1).strip()
|
||||
seg = re.sub(r"^(?:左侧|右侧|顶部|底部|页面|菜单|列表|工具栏|在.*?中|在.*?内)\s*", "", seg)
|
||||
seg = re.sub(r"(菜单项|菜单|子菜单|按钮|链接|页签|选项|入口|记录|表单)$", "", seg).strip()
|
||||
_add(seg)
|
||||
|
||||
m = re.search(r"进入\s*(.+)", part)
|
||||
if m:
|
||||
seg = m.group(1).strip()
|
||||
seg = re.sub(r"(页面|模块|菜单)$", "", seg).strip()
|
||||
_add(seg)
|
||||
|
||||
compact = target
|
||||
compact = re.sub(r"^(?:请|在.*?中|在.*?内)\s*", "", compact)
|
||||
compact = re.sub(r"^点击\s*", "", compact)
|
||||
compact = re.sub(r"(菜单项|菜单|子菜单|按钮|链接|页签|选项|入口)$", "", compact).strip()
|
||||
_add(compact)
|
||||
|
||||
return candidates
|
||||
|
||||
def _find_element_by_description(self, target: str) -> dict:
|
||||
"""根据描述找到 DOM 元素的精确坐标"""
|
||||
@@ -293,27 +462,102 @@ class ActionExecutor:
|
||||
return None
|
||||
|
||||
def _do_type(self, action: Dict[str, Any]) -> None:
|
||||
"""Execute type action"""
|
||||
"""Execute type action using semantic locators"""
|
||||
text = action.get("text", action.get("value", ""))
|
||||
if not text:
|
||||
raise ValueError("输入操作缺少文本内容")
|
||||
|
||||
logger.info(f"执行输入: '{text}'")
|
||||
|
||||
# 1. 如果有 selector，直接使用
|
||||
if "selector" in action:
|
||||
self.browser.type_text(action["selector"], text)
|
||||
else:
|
||||
# 直接键盘输入
|
||||
if self.browser.page:
|
||||
# 先清空可能的现有内容
|
||||
self.browser.page.fill(action["selector"], text)
|
||||
logger.info(f"通过 selector 填充成功: {action['selector']}")
|
||||
return
|
||||
|
||||
# 2. 尝试通过语义定位器找到输入框
|
||||
target = action.get("target", "")
|
||||
if target:
|
||||
locators = self._build_input_locators(target)
|
||||
|
||||
for locator_desc, locator in locators:
|
||||
try:
|
||||
if locator.count() > 0:
|
||||
logger.info(f"通过语义定位器找到输入框: {locator_desc}")
|
||||
locator.first.fill(text)
|
||||
logger.info(f"填充成功: '{text}'")
|
||||
self.browser.wait(100)
|
||||
return
|
||||
except Exception as e:
|
||||
logger.debug(f"定位器 {locator_desc} 失败: {e}")
|
||||
continue
|
||||
|
||||
# 3. 回退到键盘输入（兼容现有逻辑）
|
||||
if self.browser.page:
|
||||
active_element = self.browser.page.evaluate("() => document.activeElement.tagName")
|
||||
logger.info(f"当前活动元素: {active_element}")
|
||||
|
||||
# 先清空可能的现有内容
|
||||
import platform
|
||||
if platform.system() == "Darwin": # macOS
|
||||
self.browser.page.keyboard.press("Meta+a")
|
||||
else: # Windows/Linux
|
||||
self.browser.page.keyboard.press("Control+a")
|
||||
self.browser.wait(50)
|
||||
# 逐字符输入，模拟真实打字
|
||||
self.browser.page.keyboard.type(text, delay=50)
|
||||
self.browser.wait(100)
|
||||
logger.info(f"输入完成: '{text}'")
|
||||
else:
|
||||
raise RuntimeError("浏览器页面未初始化")
|
||||
self.browser.wait(50)
|
||||
|
||||
# 删除选中内容
|
||||
self.browser.page.keyboard.press("Backspace")
|
||||
self.browser.wait(50)
|
||||
|
||||
# 逐字符输入
|
||||
self.browser.page.keyboard.type(text, delay=50)
|
||||
self.browser.wait(100)
|
||||
logger.info(f"输入完成: '{text}'")
|
||||
else:
|
||||
raise RuntimeError("浏览器页面未初始化")
|
||||
|
||||
def _build_input_locators(self, target: str) -> List[Tuple[str, Any]]:
|
||||
"""Build Playwright locators for input elements"""
|
||||
locators = []
|
||||
page = self.browser.page
|
||||
|
||||
# 提取核心文本
|
||||
core_text = target.strip()
|
||||
if '"' in target:
|
||||
import re
|
||||
match = re.search(r'"([^"]+)"', target)
|
||||
if match:
|
||||
core_text = match.group(1)
|
||||
|
||||
core_text = core_text.replace("输入", "").replace("框", "").strip()
|
||||
|
||||
# 1. 通过 placeholder 匹配
|
||||
locators.append((f"input[placeholder*='{core_text}']", page.locator(f"input[placeholder*='{core_text}']")))
|
||||
locators.append((f"textarea[placeholder*='{core_text}']", page.locator(f"textarea[placeholder*='{core_text}']")))
|
||||
|
||||
# 2. 通过 label 匹配
|
||||
locators.append((f"label:has-text('{core_text}') >> input", page.locator(f"label:has-text('{core_text}') >> input")))
|
||||
locators.append((f"label:has-text('{core_text}') >> textarea", page.locator(f"label:has-text('{core_text}') >> textarea")))
|
||||
|
||||
# 3. 特定字段匹配
|
||||
if "用户名" in target or "用户账号" in target or "用户名称" in target:
|
||||
locators.append(("用户名输入框", page.locator("input[placeholder*='用户名'], input[placeholder*='账号'], input[placeholder*='用户名称']")))
|
||||
locators.append(("用户名输入", page.locator("input:has-text('用户')")))
|
||||
if "密码" in target:
|
||||
locators.append(("密码输入框", page.locator("input[type='password']")))
|
||||
if "邮箱" in target:
|
||||
locators.append(("邮箱输入框", page.locator("input[type='email'], input[placeholder*='邮箱']")))
|
||||
if "手机" in target or "电话" in target:
|
||||
locators.append(("手机号输入框", page.locator("input[placeholder*='手机'], input[placeholder*='电话']")))
|
||||
if "昵称" in target:
|
||||
locators.append(("昵称输入框", page.locator("input[placeholder*='昵称']")))
|
||||
if "备注" in target or "描述" in target:
|
||||
locators.append(("备注输入框", page.locator("textarea[placeholder*='备注'], textarea[placeholder*='描述']")))
|
||||
|
||||
# 4. 通用输入框（作为最后尝试）
|
||||
locators.append(("第一个可见输入框", page.locator("input:visible").first))
|
||||
|
||||
return locators
|
||||
|
||||
def _do_scroll(self, action: Dict[str, Any]) -> None:
|
||||
"""Execute scroll action"""
|
||||
@@ -340,22 +584,58 @@ class ActionExecutor:
|
||||
|
||||
response = self.analyzer.model.analyze(img, prompt)
|
||||
|
||||
try:
|
||||
match = re.search(r'\{.*\}', response, re.DOTALL)
|
||||
if match:
|
||||
verify_result = json.loads(match.group())
|
||||
passed = verify_result.get("passed", False)
|
||||
reason = verify_result.get("reason", "")
|
||||
|
||||
result["success"] = passed
|
||||
result["verify_passed"] = passed
|
||||
result["verify_reason"] = reason
|
||||
|
||||
if not passed:
|
||||
logger.warning(f"验证失败: {reason}")
|
||||
else:
|
||||
result["success"] = False
|
||||
result["error"] = "无法解析验证结果"
|
||||
except json.JSONDecodeError as e:
|
||||
result["success"] = False
|
||||
result["error"] = f"JSON 解析失败: {e}"
|
||||
# 使用通用解析器解析 AI 返回的 JSON
|
||||
verify_result = parse_ai_json(response, expected_type="object")
|
||||
|
||||
if verify_result:
|
||||
passed = verify_result.get("passed", False)
|
||||
reason = verify_result.get("reason", "")
|
||||
|
||||
result["success"] = passed
|
||||
result["verify_passed"] = passed
|
||||
result["verify_reason"] = reason
|
||||
|
||||
if not passed:
|
||||
logger.warning(f"验证失败: {reason}")
|
||||
else:
|
||||
# JSON 解析失败时，尝试从响应文本推断结果
|
||||
result.update(self._infer_verify_result(response, target))
|
||||
|
||||
def _infer_verify_result(self, response: str, target: str) -> dict:
|
||||
"""
|
||||
当 JSON 解析失败时，从响应文本推断验证结果
|
||||
"""
|
||||
response_lower = response.lower()
|
||||
|
||||
# 检查明确的成功/失败关键词
|
||||
success_keywords = ['成功', '满足', 'passed', 'true', '是的', '确认', '正确', 'yes']
|
||||
failure_keywords = ['失败', '不满足', 'failed', 'false', '否', '错误', '未能', 'no']
|
||||
|
||||
has_success = any(kw in response_lower for kw in success_keywords)
|
||||
has_failure = any(kw in response_lower for kw in failure_keywords)
|
||||
|
||||
if has_success and not has_failure:
|
||||
return {
|
||||
"success": True,
|
||||
"verify_passed": True,
|
||||
"verify_reason": f"(推断) 根据响应内容判断验证通过",
|
||||
"inferred": True
|
||||
}
|
||||
elif has_failure and not has_success:
|
||||
return {
|
||||
"success": False,
|
||||
"verify_passed": False,
|
||||
"verify_reason": f"(推断) 根据响应内容判断验证失败",
|
||||
"inferred": True
|
||||
}
|
||||
else:
|
||||
# 无法确定，标记为需人工复核
|
||||
logger.warning(f"无法解析验证结果，标记为待复核: {response[:100]}...")
|
||||
return {
|
||||
"success": False,
|
||||
"verify_passed": False,
|
||||
"verify_reason": "(待复核) AI 响应格式异常，无法自动判断",
|
||||
"needs_review": True,
|
||||
"raw_response": response[:500]
|
||||
}
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -6,6 +6,8 @@ import json
|
||||
import re
|
||||
import logging
|
||||
|
||||
from src.utils.json_parser import parse_ai_json
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
@@ -75,15 +77,11 @@ class TestPlanner:
|
||||
|
||||
def _parse_steps(self, response: str) -> List[Dict[str, Any]]:
|
||||
"""Parse AI response into structured steps"""
|
||||
try:
|
||||
# 尝试提取 JSON 数组
|
||||
match = re.search(r'\[[\s\S]*\]', response)
|
||||
if match:
|
||||
steps = json.loads(match.group())
|
||||
# 验证步骤格式
|
||||
return self._validate_steps(steps)
|
||||
except json.JSONDecodeError as e:
|
||||
logger.warning(f"JSON 解析失败: {e}")
|
||||
# 使用通用解析器处理各种格式异常
|
||||
steps = parse_ai_json(response, expected_type="array")
|
||||
|
||||
if steps and isinstance(steps, list):
|
||||
return self._validate_steps(steps)
|
||||
|
||||
logger.warning(f"无法解析响应: {response[:200]}")
|
||||
return [{"raw": response, "error": "解析失败"}]
|
||||
|
||||
@@ -9,7 +9,7 @@ import base64
|
||||
class BrowserController:
|
||||
"""Controls browser operations using Playwright"""
|
||||
|
||||
def __init__(self, headless: bool = False, timeout: int = 30000):
|
||||
def __init__(self, headless: bool = False, timeout: int = 60000):
|
||||
self.headless = headless
|
||||
self.timeout = timeout
|
||||
self._playwright = None
|
||||
@@ -41,6 +41,49 @@ class BrowserController:
|
||||
if self._page:
|
||||
self._page.click(selector)
|
||||
|
||||
def click_text(self, text: str, exact: bool = False) -> bool:
|
||||
if not self._page or not text:
|
||||
return False
|
||||
candidates = [
|
||||
("menuitem", text),
|
||||
("button", text),
|
||||
("link", text),
|
||||
("tab", text),
|
||||
("treeitem", text),
|
||||
("listitem", text),
|
||||
("option", text),
|
||||
]
|
||||
for role, name in candidates:
|
||||
try:
|
||||
locator = self._page.get_by_role(role, name=name, exact=exact)
|
||||
if locator.count() > 0:
|
||||
locator.first.click()
|
||||
return True
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
try:
|
||||
locator = self._page.get_by_text(text, exact=exact)
|
||||
if locator.count() > 0:
|
||||
locator.first.click()
|
||||
return True
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
return False
|
||||
|
||||
def click_role(self, role: str, name: str, exact: bool = False) -> bool:
|
||||
if not self._page or not role or not name:
|
||||
return False
|
||||
try:
|
||||
locator = self._page.get_by_role(role, name=name, exact=exact)
|
||||
if locator.count() > 0:
|
||||
locator.first.click()
|
||||
return True
|
||||
except Exception:
|
||||
return False
|
||||
return False
|
||||
|
||||
def click_at(self, x: int, y: int) -> bool:
|
||||
"""Click at specific coordinates using JavaScript for better compatibility
|
||||
|
||||
@@ -69,6 +112,123 @@ class BrowserController:
|
||||
return True
|
||||
return False
|
||||
|
||||
def find_element_by_text(self, text: str) -> Optional[Dict[str, Any]]:
|
||||
"""Find an element by its text and return its coordinates and info"""
|
||||
if not self._page:
|
||||
return None
|
||||
|
||||
return self._page.evaluate("""
|
||||
(searchText) => {
|
||||
// 提取引号内的核心文本
|
||||
let search = searchText;
|
||||
const match = searchText.match(/["'“”‘’]([^"'“”‘’]+)["'“”‘’]/);
|
||||
if (match) {
|
||||
search = match[1];
|
||||
} else {
|
||||
search = searchText.replace(/菜单|点击|展开|跳转|进入|'|"/g, '').trim();
|
||||
}
|
||||
search = search.toLowerCase();
|
||||
|
||||
const isNavTarget = searchText.includes('管理') || searchText.includes('菜单') || searchText.includes('事项');
|
||||
|
||||
const elements = Array.from(document.querySelectorAll('a, button, span, div, li, [role="button"], [role="menuitem"], p, h1, h2, h3'));
|
||||
|
||||
const candidates = elements.map(el => {
|
||||
const text = (el.innerText || el.textContent || "").toLowerCase().trim();
|
||||
const rect = el.getBoundingClientRect();
|
||||
|
||||
if (!text.includes(search)) return null;
|
||||
|
||||
let score = 0;
|
||||
// 1. 文本长度偏差越小分数越高 (精确匹配权重极大)
|
||||
const lengthDiff = Math.abs(text.length - search.length);
|
||||
if (text === search) score += 2000;
|
||||
else score += 1000 / (1 + lengthDiff * 5);
|
||||
|
||||
// 2. 包含在侧边栏中加分
|
||||
const isSidebar = el.closest('aside, .ant-layout-sider, .sidebar, #sidebar') !== null;
|
||||
if (isNavTarget && isSidebar) score += 100;
|
||||
|
||||
// 3. 强优先叶子节点
|
||||
const children = Array.from(el.children);
|
||||
const hasMatchingChild = children.some(c => (c.innerText || c.textContent || "").toLowerCase().includes(search));
|
||||
if (hasMatchingChild) score -= 500; // 如果子节点也匹配，父节点几乎不可能胜出
|
||||
|
||||
// 如果本身就是叶子节点，额外加分
|
||||
if (el.querySelectorAll('*').length === 0) score += 100;
|
||||
|
||||
// 状态检测 (支持 AntD, Vben, ElementUI 等)
|
||||
const classList = Array.from(el.classList).join(' ').toLowerCase();
|
||||
const parentClassList = el.parentElement ? Array.from(el.parentElement.classList).join(' ').toLowerCase() : '';
|
||||
const combinedClasses = (classList + ' ' + parentClassList);
|
||||
|
||||
const liParent = el.closest('li');
|
||||
const isExpanded = combinedClasses.includes('open') ||
|
||||
combinedClasses.includes('expanded') ||
|
||||
combinedClasses.includes('is-opened') ||
|
||||
el.closest('[aria-expanded="true"]') !== null ||
|
||||
(liParent && liParent.querySelector('ul') && liParent.querySelector('ul').getBoundingClientRect().height > 5);
|
||||
|
||||
const isActive = combinedClasses.includes('active') ||
|
||||
combinedClasses.includes('selected') ||
|
||||
combinedClasses.includes('current') ||
|
||||
combinedClasses.includes('is-active');
|
||||
|
||||
// 4. 框架特定优先权 (Vben, AntD)
|
||||
const isLeaf = combinedClasses.includes('menu-item') ||
|
||||
combinedClasses.includes('normal-menu__item') ||
|
||||
combinedClasses.includes('menu-item__content');
|
||||
const isCategory = combinedClasses.includes('sub-menu') ||
|
||||
combinedClasses.includes('submenu') ||
|
||||
combinedClasses.includes('sub-menu-content');
|
||||
|
||||
if (isLeaf && !isCategory) score += 1000; // 绝对优先叶子节点
|
||||
if (isCategory) score -= 1000; // 绝对惩罚分类
|
||||
|
||||
// 5. 对已展开/激活状态的微调
|
||||
if (isExpanded) score -= 1000; // 惩罚已展开的
|
||||
if (isActive) score += 50; // 激活状态通常是好的
|
||||
|
||||
return { el, score, rect, text: text.substring(0, 30), isExpanded, isActive };
|
||||
}).filter(x => x !== null);
|
||||
|
||||
if (candidates.length > 0) {
|
||||
candidates.sort((a, b) => b.score - a.score);
|
||||
const best = candidates[0];
|
||||
console.log(`[find_element_by_text] Best match: "${best.text}" score=${best.score} at (${best.rect.left}, ${best.rect.top})`);
|
||||
|
||||
// 检测是否已展开或激活 (支持 AntD, Vben, ElementUI 等)
|
||||
const classList = Array.from(best.el.classList).join(' ').toLowerCase();
|
||||
const parentClassList = best.el.parentElement ? Array.from(best.el.parentElement.classList).join(' ').toLowerCase() : '';
|
||||
const combinedClasses = (classList + ' ' + parentClassList);
|
||||
|
||||
const isExpanded = combinedClasses.includes('open') ||
|
||||
combinedClasses.includes('expanded') ||
|
||||
best.el.closest('[aria-expanded="true"]') !== null;
|
||||
|
||||
const isActive = combinedClasses.includes('active') ||
|
||||
combinedClasses.includes('selected') ||
|
||||
combinedClasses.includes('current');
|
||||
|
||||
// 优先返回更深层的交互容器 (li, a, button) 而非内部的 span
|
||||
const container = best.el.closest('a, button, li[role="menuitem"], .vben-normal-menu__item, .ant-menu-item');
|
||||
const targetEl = container || best.el;
|
||||
const targetRect = targetEl.getBoundingClientRect();
|
||||
|
||||
return {
|
||||
x: Math.round(targetRect.left + targetRect.width / 2),
|
||||
y: Math.round(targetRect.top + targetRect.height / 2),
|
||||
tagName: targetEl.tagName,
|
||||
text: best.text,
|
||||
score: best.score,
|
||||
isExpanded: isExpanded,
|
||||
isActive: isActive
|
||||
};
|
||||
}
|
||||
return null;
|
||||
}
|
||||
""", text)
|
||||
|
||||
def type_text(self, selector: str, text: str) -> None:
|
||||
"""Type text into element"""
|
||||
if self._page:
|
||||
@@ -89,6 +249,20 @@ class BrowserController:
|
||||
if self._page:
|
||||
self._page.wait_for_timeout(ms)
|
||||
|
||||
def wait_for_load_state(self, state: str = "networkidle", timeout: int = None) -> None:
|
||||
"""Wait for page load state
|
||||
|
||||
Args:
|
||||
state: Load state to wait for - 'load', 'domcontentloaded', or 'networkidle'
|
||||
timeout: Optional timeout in milliseconds
|
||||
"""
|
||||
if self._page:
|
||||
try:
|
||||
self._page.wait_for_load_state(state, timeout=timeout)
|
||||
except Exception:
|
||||
# 超时不应阻塞测试继续
|
||||
pass
|
||||
|
||||
def screenshot(self, full_page: bool = False) -> bytes:
|
||||
"""Take screenshot and return as bytes"""
|
||||
if self._page:
|
||||
|
||||
45
src/main.py
45
src/main.py
@@ -6,6 +6,9 @@ from .browser import BrowserController, ScreenshotManager
|
||||
from .vision import PageAnalyzer
|
||||
from .agent import TestPlanner, ActionExecutor
|
||||
from .reporter import ReportGenerator
|
||||
import logging
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class WebTester:
|
||||
@@ -52,7 +55,10 @@ class WebTester:
|
||||
|
||||
# Execute each step
|
||||
for step in steps:
|
||||
executor.execute_action(step)
|
||||
result = executor.execute_action(step)
|
||||
if not result.get("success", False):
|
||||
logger.warning(f"测试步骤执行失败，停止后续操作: {step}")
|
||||
break
|
||||
self.browser.wait(500)
|
||||
|
||||
# Generate report
|
||||
@@ -131,24 +137,33 @@ class WebTester:
|
||||
import re
|
||||
|
||||
try:
|
||||
# 尝试提取 JSON
|
||||
match = re.search(r'\{.*\}', response, re.DOTALL)
|
||||
if match:
|
||||
result = json.loads(match.group())
|
||||
# 改进的 JSON 提取逻辑：从后往前找最后一个 }，从前往后找第一个 {
|
||||
start = response.find('{')
|
||||
end = response.rfind('}')
|
||||
if start != -1 and end != -1:
|
||||
content = response[start:end+1]
|
||||
# 清除可能干扰解析的隐藏字符
|
||||
content = re.sub(r'[\x00-\x1F\x7F-\x9F]', '', content)
|
||||
try:
|
||||
result = json.loads(content)
|
||||
except json.JSONDecodeError:
|
||||
# 如果标准解析失败，尝试修复常见的引号错误
|
||||
fixed_content = re.sub(r"'(.*?)'", r'"\1"', content)
|
||||
result = json.loads(fixed_content)
|
||||
|
||||
return {
|
||||
"passed": result.get("passed", False),
|
||||
"condition": condition,
|
||||
"reason": result.get("reason", "无法解析 AI 响应"),
|
||||
"reason": result.get("reason", "AI 验证成功但未提供原因")
|
||||
}
|
||||
except json.JSONDecodeError:
|
||||
pass
|
||||
|
||||
# 解析失败，返回原始响应
|
||||
return {
|
||||
"passed": False,
|
||||
"condition": condition,
|
||||
"reason": f"AI 响应解析失败: {response[:200]}",
|
||||
}
|
||||
else:
|
||||
raise ValueError("未在响应中发现 JSON 结构")
|
||||
except Exception as e:
|
||||
return {
|
||||
"passed": False,
|
||||
"condition": condition,
|
||||
"reason": f"AI 响应解析异常: {str(e)}\n原始响应: {response[:100]}..."
|
||||
}
|
||||
|
||||
def save_baseline(self, name: str) -> str:
|
||||
"""
|
||||
|
||||
@@ -17,12 +17,19 @@ class ReportGenerator:
|
||||
self.output_dir = Path(output_dir)
|
||||
self.output_dir.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
def _sanitize_filename(self, name: str) -> str:
|
||||
"""Sanitize filename by replacing invalid characters"""
|
||||
import re
|
||||
# Replace slashes, backslashes, and other common invalid filename characters
|
||||
return re.sub(r'[\\/*?:"<>|]', '_', name)
|
||||
|
||||
def generate(self, test_name: str, actions: List[Dict],
|
||||
screenshots: List[str] = None) -> Path:
|
||||
"""Generate HTML report"""
|
||||
html = self._build_html(test_name, actions, screenshots or [])
|
||||
|
||||
filename = f"{test_name}_{datetime.now():%Y%m%d_%H%M%S}.html"
|
||||
sanitized_name = self._sanitize_filename(test_name)
|
||||
filename = f"{sanitized_name}_{datetime.now():%Y%m%d_%H%M%S}.html"
|
||||
filepath = self.output_dir / filename
|
||||
filepath.write_text(html, encoding="utf-8")
|
||||
|
||||
@@ -477,4 +484,363 @@ class ReportGenerator:
|
||||
</div>
|
||||
<script>mermaid.initialize({{startOnLoad:true, theme:'neutral'}});</script>
|
||||
</body>
|
||||
</html>'''
|
||||
|
||||
def generate_session_report(self, session_name: str, result: Dict[str, Any]) -> Path:
|
||||
"""
|
||||
生成一次完整测试会话的汇总报告
|
||||
|
||||
Args:
|
||||
session_name: 测试会话名称
|
||||
result: 包含所有步骤的结果字典
|
||||
|
||||
Returns:
|
||||
报告文件路径
|
||||
"""
|
||||
sanitized_name = self._sanitize_filename(session_name)
|
||||
filename = f"{sanitized_name}_{datetime.now():%Y%m%d_%H%M%S}.html"
|
||||
filepath = self.output_dir / filename
|
||||
|
||||
html = self._build_session_html(session_name, result)
|
||||
filepath.write_text(html, encoding="utf-8")
|
||||
|
||||
# 同时保存 JSON 结果
|
||||
json_path = filepath.with_suffix(".json")
|
||||
json_path.write_text(
|
||||
json.dumps(result, ensure_ascii=False, indent=2, default=str),
|
||||
encoding="utf-8"
|
||||
)
|
||||
|
||||
logger.info(f"会话报告已生成: {filepath}")
|
||||
return filepath
|
||||
|
||||
def _build_session_html(self, session_name: str, result: Dict[str, Any]) -> str:
|
||||
"""构建会话汇总报告 HTML"""
|
||||
timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
|
||||
status = result.get("status", "unknown")
|
||||
status_icon = "✅" if status == "passed" else "❌"
|
||||
status_class = "passed" if status == "passed" else "failed"
|
||||
|
||||
# 统计信息
|
||||
steps = result.get("steps", [])
|
||||
total_steps = len(steps)
|
||||
|
||||
# 从 explore 步骤中提取统计数据
|
||||
total_clicks = 0
|
||||
total_pages = 0
|
||||
total_elements = 0
|
||||
visited_urls = set()
|
||||
all_action_logs = []
|
||||
|
||||
for step in steps:
|
||||
step_result = step.get("result", {})
|
||||
if step.get("action") == "explore":
|
||||
total_clicks += step_result.get("click_count", 0)
|
||||
urls = step_result.get("visited_urls", [])
|
||||
visited_urls.update(urls)
|
||||
total_pages = len(visited_urls)
|
||||
# 收集所有操作日志
|
||||
action_log = step_result.get("action_log", [])
|
||||
all_action_logs.extend(action_log)
|
||||
|
||||
# 错误列表
|
||||
errors = result.get("errors", [])
|
||||
errors_html = ""
|
||||
if errors:
|
||||
errors_html = '<div class="errors-section"><h2>❌ 错误信息</h2><div class="error-list">'
|
||||
for err in errors:
|
||||
errors_html += f'<div class="error-item">{err}</div>'
|
||||
errors_html += '</div></div>'
|
||||
|
||||
# 步骤列表 HTML
|
||||
steps_html = ""
|
||||
for i, step in enumerate(steps, 1):
|
||||
action = step.get("action", "unknown")
|
||||
step_result = step.get("result", {})
|
||||
success = step_result.get("success", True) if isinstance(step_result, dict) else True
|
||||
|
||||
step_icon = "✅" if success else "❌"
|
||||
step_status_class = "success" if success else "failed"
|
||||
|
||||
# 步骤详情
|
||||
detail = ""
|
||||
if action == "explore":
|
||||
clicks = step_result.get("click_count", 0)
|
||||
urls = step_result.get("visited_urls", [])
|
||||
detail = f"点击 {clicks} 次，访问 {len(urls)} 个页面"
|
||||
elif action == "goal":
|
||||
detail = step.get("goal", "")
|
||||
elif action == "verify":
|
||||
detail = step.get("target", "")
|
||||
elif action == "wait":
|
||||
detail = f"等待 {step.get('duration', 0)}ms"
|
||||
|
||||
steps_html += f'''
|
||||
<div class="step-item {step_status_class}">
|
||||
<div class="step-header">
|
||||
<span class="step-num">步骤 {i}</span>
|
||||
<span class="step-action">{action}</span>
|
||||
<span class="step-icon">{step_icon}</span>
|
||||
</div>
|
||||
<div class="step-detail">{detail}</div>
|
||||
</div>'''
|
||||
|
||||
# 访问页面列表
|
||||
pages_html = ""
|
||||
for url in sorted(visited_urls):
|
||||
pages_html += f'<div class="page-item">{url}</div>'
|
||||
|
||||
# 操作日志 HTML
|
||||
log_html = ""
|
||||
for log in all_action_logs[-100:]: # 最多显示最后 100 条
|
||||
el = log.get("element", {}) if isinstance(log.get("element"), dict) else {}
|
||||
name = el.get("name", "") if el else ""
|
||||
etype = el.get("type", "") if el else ""
|
||||
scope = el.get("scope", "") if el else ""
|
||||
action_type = log.get("action_type", "click")
|
||||
success = log.get("success", True)
|
||||
url_changed = log.get("url_changed", False)
|
||||
screenshot = log.get("screenshot_after", "")
|
||||
error = log.get("error", "")
|
||||
|
||||
# 状态图标
|
||||
status_icon = "✅" if success else "❌"
|
||||
status_class = "success" if success else "failed"
|
||||
|
||||
# URL 变化标记
|
||||
url_badge = '<span class="url-changed">🔀 跳转</span>' if url_changed else ""
|
||||
|
||||
# 元素类型标签
|
||||
type_badge = f'<span class="element-type">{etype}</span>' if etype else ""
|
||||
scope_badge = f'<span class="element-scope">{scope}</span>' if scope else ""
|
||||
|
||||
# 错误信息
|
||||
error_html = f'<div class="log-error">{error}</div>' if error else ""
|
||||
|
||||
# 截图（使用 details 标签可折叠）
|
||||
screenshot_html = ""
|
||||
if screenshot:
|
||||
screenshot_html = f'''
|
||||
<details class="screenshot-toggle">
|
||||
<summary>📷 查看截图</summary>
|
||||
<img src="data:image/png;base64,{screenshot}" class="log-screenshot">
|
||||
</details>'''
|
||||
|
||||
log_html += f'''
|
||||
<div class="log-item {status_class}">
|
||||
<span class="log-step">{log.get("step", 0)}</span>
|
||||
<span class="log-status">{status_icon}</span>
|
||||
<span class="log-name">{name}</span>
|
||||
{type_badge}
|
||||
{scope_badge}
|
||||
<span class="log-action">{action_type}</span>
|
||||
{url_badge}
|
||||
{error_html}
|
||||
{screenshot_html}
|
||||
</div>'''
|
||||
|
||||
return f'''<!DOCTYPE html>
|
||||
<html lang="zh-CN">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||||
<title>{session_name} - 测试报告</title>
|
||||
<style>
|
||||
* {{ box-sizing: border-box; margin: 0; padding: 0; }}
|
||||
body {{
|
||||
font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
|
||||
background: #0f172a;
|
||||
color: #e2e8f0;
|
||||
line-height: 1.6;
|
||||
}}
|
||||
.container {{ max-width: 1200px; margin: 0 auto; padding: 20px; }}
|
||||
.header {{
|
||||
background: linear-gradient(135deg, #6366f1 0%, #8b5cf6 100%);
|
||||
padding: 40px;
|
||||
border-radius: 16px;
|
||||
margin-bottom: 30px;
|
||||
}}
|
||||
.header h1 {{ font-size: 2em; margin-bottom: 10px; display: flex; align-items: center; gap: 10px; }}
|
||||
.header .status {{ font-size: 1.5em; }}
|
||||
.header p {{ opacity: 0.9; }}
|
||||
.stats {{
|
||||
display: grid;
|
||||
grid-template-columns: repeat(4, 1fr);
|
||||
gap: 20px;
|
||||
margin-bottom: 30px;
|
||||
}}
|
||||
.stat-card {{
|
||||
background: #1e293b;
|
||||
padding: 20px;
|
||||
border-radius: 12px;
|
||||
text-align: center;
|
||||
}}
|
||||
.stat-card .number {{ font-size: 2.5em; font-weight: bold; color: #818cf8; }}
|
||||
.stat-card.passed .number {{ color: #4ade80; }}
|
||||
.stat-card.failed .number {{ color: #f87171; }}
|
||||
h2 {{ margin: 30px 0 15px; color: #f1f5f9; }}
|
||||
.section {{ background: #1e293b; border-radius: 12px; padding: 20px; margin-bottom: 20px; }}
|
||||
.step-item {{
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
padding: 15px;
|
||||
border-bottom: 1px solid #334155;
|
||||
}}
|
||||
.step-item.success {{ border-left: 4px solid #4ade80; }}
|
||||
.step-item.failed {{ border-left: 4px solid #f87171; }}
|
||||
.step-header {{ display: flex; align-items: center; gap: 15px; margin-bottom: 8px; }}
|
||||
.step-num {{
|
||||
background: #6366f1;
|
||||
color: white;
|
||||
padding: 4px 12px;
|
||||
border-radius: 4px;
|
||||
font-size: 0.85em;
|
||||
}}
|
||||
.step-action {{
|
||||
background: #334155;
|
||||
padding: 4px 10px;
|
||||
border-radius: 4px;
|
||||
text-transform: uppercase;
|
||||
font-size: 0.85em;
|
||||
}}
|
||||
.step-icon {{ margin-left: auto; font-size: 1.2em; }}
|
||||
.step-detail {{ color: #94a3b8; font-size: 0.95em; }}
|
||||
.page-item {{
|
||||
padding: 10px;
|
||||
border-bottom: 1px solid #334155;
|
||||
font-family: monospace;
|
||||
font-size: 0.9em;
|
||||
color: #94a3b8;
|
||||
}}
|
||||
.errors-section {{ margin-bottom: 20px; }}
|
||||
.error-list {{ background: #1e293b; border-radius: 12px; padding: 15px; }}
|
||||
.error-item {{
|
||||
padding: 10px;
|
||||
border-bottom: 1px solid #334155;
|
||||
color: #f87171;
|
||||
}}
|
||||
.log-item {{
|
||||
display: flex;
|
||||
align-items: center;
|
||||
padding: 10px;
|
||||
border-bottom: 1px solid #334155;
|
||||
gap: 10px;
|
||||
flex-wrap: wrap;
|
||||
}}
|
||||
.log-item.success {{ border-left: 3px solid #4ade80; }}
|
||||
.log-item.failed {{ border-left: 3px solid #f87171; background: rgba(248, 113, 113, 0.1); }}
|
||||
.log-step {{
|
||||
background: #6366f1;
|
||||
color: white;
|
||||
padding: 4px 10px;
|
||||
border-radius: 4px;
|
||||
min-width: 40px;
|
||||
text-align: center;
|
||||
font-weight: bold;
|
||||
}}
|
||||
.log-status {{ font-size: 1.2em; }}
|
||||
.log-name {{ flex: 1; font-weight: 500; }}
|
||||
.log-action {{
|
||||
background: #334155;
|
||||
padding: 4px 8px;
|
||||
border-radius: 4px;
|
||||
font-size: 0.85em;
|
||||
text-transform: uppercase;
|
||||
}}
|
||||
.element-type {{
|
||||
background: #4f46e5;
|
||||
color: white;
|
||||
padding: 2px 6px;
|
||||
border-radius: 4px;
|
||||
font-size: 0.75em;
|
||||
}}
|
||||
.element-scope {{
|
||||
background: #0d9488;
|
||||
color: white;
|
||||
padding: 2px 6px;
|
||||
border-radius: 4px;
|
||||
font-size: 0.75em;
|
||||
}}
|
||||
.url-changed {{
|
||||
background: #f59e0b;
|
||||
color: white;
|
||||
padding: 2px 6px;
|
||||
border-radius: 4px;
|
||||
font-size: 0.75em;
|
||||
}}
|
||||
.log-error {{
|
||||
width: 100%;
|
||||
color: #f87171;
|
||||
font-size: 0.85em;
|
||||
padding: 5px 10px;
|
||||
background: rgba(248, 113, 113, 0.15);
|
||||
border-radius: 4px;
|
||||
margin-top: 5px;
|
||||
}}
|
||||
.screenshot-toggle {{
|
||||
width: 100%;
|
||||
margin-top: 8px;
|
||||
}}
|
||||
.screenshot-toggle summary {{
|
||||
cursor: pointer;
|
||||
color: #818cf8;
|
||||
font-size: 0.85em;
|
||||
padding: 4px 0;
|
||||
}}
|
||||
.screenshot-toggle summary:hover {{
|
||||
color: #a5b4fc;
|
||||
}}
|
||||
.log-screenshot {{
|
||||
max-width: 100%;
|
||||
border-radius: 8px;
|
||||
margin-top: 10px;
|
||||
box-shadow: 0 4px 12px rgba(0,0,0,0.3);
|
||||
}}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<div class="container">
|
||||
<div class="header">
|
||||
<h1>📋 {session_name} <span class="status">{status_icon}</span></h1>
|
||||
<p>生成时间: {timestamp}</p>
|
||||
<p>起始 URL: {result.get("url", "")}</p>
|
||||
</div>
|
||||
|
||||
<div class="stats">
|
||||
<div class="stat-card {status_class}">
|
||||
<div class="number">{status_icon}</div>
|
||||
<div>测试状态</div>
|
||||
</div>
|
||||
<div class="stat-card">
|
||||
<div class="number">{total_steps}</div>
|
||||
<div>执行步骤</div>
|
||||
</div>
|
||||
<div class="stat-card">
|
||||
<div class="number">{total_clicks}</div>
|
||||
<div>点击次数</div>
|
||||
</div>
|
||||
<div class="stat-card">
|
||||
<div class="number">{total_pages}</div>
|
||||
<div>访问页面</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
{errors_html}
|
||||
|
||||
<h2>📝 执行步骤</h2>
|
||||
<div class="section">
|
||||
{steps_html if steps_html else '<div style="color:#94a3b8;">暂无步骤记录</div>'}
|
||||
</div>
|
||||
|
||||
<h2>🗺️ 访问页面</h2>
|
||||
<div class="section">
|
||||
{pages_html if pages_html else '<div style="color:#94a3b8;">暂无页面记录</div>'}
|
||||
</div>
|
||||
|
||||
<h2>📜 操作日志 (最近 {len(all_action_logs)} 条，最多显示 100 条)</h2>
|
||||
<div class="section">
|
||||
{log_html if log_html else '<div style="color:#94a3b8;">暂无操作日志</div>'}
|
||||
</div>
|
||||
</div>
|
||||
</body>
|
||||
</html>'''
|
||||
|
||||
167
src/utils/json_parser.py
Normal file
167
src/utils/json_parser.py
Normal file
@@ -0,0 +1,167 @@
|
||||
"""
|
||||
Robust JSON Parser for AI Responses
|
||||
|
||||
处理 AI 模型返回的各种格式不规范的 JSON 响应
|
||||
"""
|
||||
import json
|
||||
import re
|
||||
import logging
|
||||
from typing import Any, Optional, Union, List
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
def parse_ai_json(response: str, expected_type: str = "object") -> Optional[Union[dict, list]]:
|
||||
"""
|
||||
鲁棒地解析 AI 返回的 JSON 响应
|
||||
|
||||
Args:
|
||||
response: AI 返回的原始响应字符串
|
||||
expected_type: 期望的 JSON 类型，"object" 或 "array"
|
||||
|
||||
Returns:
|
||||
解析后的 dict 或 list，解析失败返回 None
|
||||
|
||||
处理的常见问题：
|
||||
- AI 在 JSON 前后添加了额外文字（如解释性文本）
|
||||
- JSON 中包含未转义的特殊字符
|
||||
- 使用单引号而非双引号
|
||||
- Python 风格的布尔值 (True/False) 和 None
|
||||
- 尾部逗号
|
||||
- Markdown 代码块包裹
|
||||
"""
|
||||
if not response:
|
||||
return None
|
||||
|
||||
# 1. 尝试直接解析（最快路径）
|
||||
try:
|
||||
result = json.loads(response.strip())
|
||||
if _validate_type(result, expected_type):
|
||||
return result
|
||||
except json.JSONDecodeError:
|
||||
pass
|
||||
|
||||
# 2. 预处理：移除 markdown 代码块
|
||||
cleaned = _remove_markdown_wrapper(response)
|
||||
|
||||
# 3. 尝试直接解析清理后的内容
|
||||
try:
|
||||
result = json.loads(cleaned)
|
||||
if _validate_type(result, expected_type):
|
||||
return result
|
||||
except json.JSONDecodeError:
|
||||
pass
|
||||
|
||||
# 4. 根据期望类型使用正则提取
|
||||
if expected_type == "array":
|
||||
extracted = _extract_json_array(cleaned)
|
||||
else:
|
||||
extracted = _extract_json_object(cleaned)
|
||||
|
||||
if extracted:
|
||||
# 应用修复后尝试解析
|
||||
fixed = _fix_common_issues(extracted)
|
||||
try:
|
||||
result = json.loads(fixed)
|
||||
if _validate_type(result, expected_type):
|
||||
return result
|
||||
except json.JSONDecodeError:
|
||||
pass
|
||||
|
||||
# 5. 最后尝试：全文修复后提取
|
||||
full_fixed = _fix_common_issues(cleaned)
|
||||
if expected_type == "array":
|
||||
extracted = _extract_json_array(full_fixed)
|
||||
else:
|
||||
extracted = _extract_json_object(full_fixed)
|
||||
|
||||
if extracted:
|
||||
try:
|
||||
result = json.loads(extracted)
|
||||
if _validate_type(result, expected_type):
|
||||
return result
|
||||
except json.JSONDecodeError as e:
|
||||
logger.debug(f"最终解析失败: {e}")
|
||||
|
||||
logger.warning(f"JSON 解析失败，响应前200字符: {response[:200]}...")
|
||||
return None
|
||||
|
||||
|
||||
def _validate_type(obj: Any, expected_type: str) -> bool:
|
||||
"""验证解析结果类型"""
|
||||
if expected_type == "array":
|
||||
return isinstance(obj, list)
|
||||
elif expected_type == "object":
|
||||
return isinstance(obj, dict)
|
||||
return True
|
||||
|
||||
|
||||
def _remove_markdown_wrapper(text: str) -> str:
|
||||
"""移除 Markdown 代码块包裹"""
|
||||
s = text.strip()
|
||||
|
||||
# 移除 ```json ... ``` 或 ``` ... ```
|
||||
s = re.sub(r'^```(?:json|JSON)?\s*\n?', '', s)
|
||||
s = re.sub(r'\n?```\s*$', '', s)
|
||||
|
||||
return s.strip()
|
||||
|
||||
|
||||
def _extract_json_object(text: str) -> Optional[str]:
|
||||
"""从文本中提取 JSON 对象"""
|
||||
# 匹配最外层的大括号（支持嵌套）
|
||||
patterns = [
|
||||
r'\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\}', # 支持两层嵌套
|
||||
r'\{(?:[^{}]|\{[^{}]*\})*\}', # 支持一层嵌套
|
||||
r'\{[^{}]*\}', # 简单单层
|
||||
]
|
||||
|
||||
for pattern in patterns:
|
||||
match = re.search(pattern, text, re.DOTALL)
|
||||
if match:
|
||||
return match.group()
|
||||
|
||||
return None
|
||||
|
||||
|
||||
def _extract_json_array(text: str) -> Optional[str]:
|
||||
"""从文本中提取 JSON 数组"""
|
||||
# 匹配最外层的方括号（支持嵌套对象）
|
||||
patterns = [
|
||||
r'\[(?:[^\[\]]|\{(?:[^{}]|\{[^{}]*\})*\}|\[(?:[^\[\]]|\[[^\[\]]*\])*\])*\]',
|
||||
r'\[[\s\S]*\]', # 贪婪匹配整个数组
|
||||
]
|
||||
|
||||
for pattern in patterns:
|
||||
match = re.search(pattern, text, re.DOTALL)
|
||||
if match:
|
||||
return match.group()
|
||||
|
||||
return None
|
||||
|
||||
|
||||
def _fix_common_issues(json_str: str) -> str:
|
||||
"""修复 JSON 字符串中的常见格式问题"""
|
||||
s = json_str
|
||||
|
||||
# 1. 修复 Python 风格的布尔值和 None
|
||||
s = re.sub(r'\bTrue\b', 'true', s)
|
||||
s = re.sub(r'\bFalse\b', 'false', s)
|
||||
s = re.sub(r'\bNone\b', 'null', s)
|
||||
|
||||
# 2. 修复单引号键名（简单情况）
|
||||
# 匹配 {'key': 或 , 'key':
|
||||
s = re.sub(r"(?<=[{,])\s*'([^']+)'\s*:", r'"\1":', s)
|
||||
|
||||
# 3. 修复单引号字符串值（简单情况）
|
||||
# 匹配 : 'value' 后跟 , 或 }
|
||||
s = re.sub(r":\s*'([^']*)'(?=\s*[,}\]])", r': "\1"', s)
|
||||
|
||||
# 4. 移除尾部逗号
|
||||
s = re.sub(r',\s*([}\]])', r'\1', s)
|
||||
|
||||
# 5. 修复缺少逗号的情况（简单场景）
|
||||
# 例如 "value1" "key2" -> "value1", "key2"
|
||||
s = re.sub(r'"\s*\n\s*"(?=[a-zA-Z_])', '",\n"', s)
|
||||
|
||||
return s
|
||||
@@ -1,5 +1,7 @@
|
||||
# Vision module - AI-powered page analysis
|
||||
from .analyzer import PageAnalyzer
|
||||
from .models import VisionModel, ClaudeVision, OpenAIVision
|
||||
from .models import VisionModel, ClaudeVision, OpenAIVision, MiMoVision, GLMVision
|
||||
|
||||
__all__ = ["PageAnalyzer", "VisionModel", "ClaudeVision", "OpenAIVision", "MiMoVision", "GLMVision"]
|
||||
|
||||
|
||||
__all__ = ["PageAnalyzer", "VisionModel", "ClaudeVision", "OpenAIVision"]
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
Page Analyzer - AI-powered page understanding
|
||||
"""
|
||||
from typing import Dict, Any, List, Optional
|
||||
from .models import VisionModel, ClaudeVision, OpenAIVision
|
||||
from .models import VisionModel, ClaudeVision, OpenAIVision, MiMoVision, GLMVision
|
||||
|
||||
|
||||
class PageAnalyzer:
|
||||
@@ -16,8 +16,12 @@ class PageAnalyzer:
|
||||
return ClaudeVision()
|
||||
elif model_name == "openai":
|
||||
return OpenAIVision()
|
||||
elif model_name == "mimo":
|
||||
return MiMoVision()
|
||||
elif model_name == "glm":
|
||||
return GLMVision()
|
||||
else:
|
||||
raise ValueError(f"Unknown model: {model_name}")
|
||||
raise ValueError(f"Unknown model: {model_name}. Supported: claude, openai, mimo, glm")
|
||||
|
||||
def analyze_page(self, image_base64: str) -> Dict[str, Any]:
|
||||
"""Analyze page structure and content"""
|
||||
|
||||
@@ -7,6 +7,7 @@ from functools import wraps
|
||||
import os
|
||||
import time
|
||||
import logging
|
||||
import requests
|
||||
|
||||
# 自动加载 .env 文件
|
||||
from dotenv import load_dotenv
|
||||
@@ -76,7 +77,7 @@ def validate_api_config(provider: str = "anthropic") -> dict:
|
||||
验证 API 配置是否正确
|
||||
|
||||
Args:
|
||||
provider: API 提供商 ("anthropic" 或 "openai")
|
||||
provider: API 提供商 ("anthropic", "openai", "mimo")
|
||||
|
||||
Returns:
|
||||
配置信息字典
|
||||
@@ -110,6 +111,34 @@ def validate_api_config(provider: str = "anthropic") -> dict:
|
||||
"model": os.getenv("OPENAI_MODEL", "gpt-4o"),
|
||||
"timeout": int(os.getenv("API_TIMEOUT", 60)),
|
||||
}
|
||||
elif provider == "mimo":
|
||||
# MiMo API (小米大模型)
|
||||
api_key = os.getenv("MIMO_API_KEY") or os.getenv("ANTHROPIC_API_KEY")
|
||||
if not api_key:
|
||||
raise ConfigurationError(
|
||||
"未设置 MIMO_API_KEY 或 ANTHROPIC_API_KEY 环境变量。\n"
|
||||
"请复制 .env.example 为 .env 并填入 API Key。"
|
||||
)
|
||||
return {
|
||||
"api_key": api_key,
|
||||
"base_url": os.getenv("MIMO_BASE_URL", "https://api.xiaomimimo.com/anthropic/v1/messages"),
|
||||
"model": os.getenv("MIMO_MODEL", "mimo-v2-flash"),
|
||||
"timeout": int(os.getenv("API_TIMEOUT", 60)),
|
||||
}
|
||||
elif provider == "glm":
|
||||
# 智谱 GLM API
|
||||
api_key = os.getenv("GLM_API_KEY") or os.getenv("ZHIPU_API_KEY")
|
||||
if not api_key:
|
||||
raise ConfigurationError(
|
||||
"未设置 GLM_API_KEY 或 ZHIPU_API_KEY 环境变量。\n"
|
||||
"请复制 .env.example 为 .env 并填入 API Key。"
|
||||
)
|
||||
return {
|
||||
"api_key": api_key,
|
||||
"base_url": os.getenv("GLM_BASE_URL", "https://open.bigmodel.cn/api/paas/v4/chat/completions"),
|
||||
"model": os.getenv("GLM_MODEL", "glm-4.6v-flash"),
|
||||
"timeout": int(os.getenv("API_TIMEOUT", 60)),
|
||||
}
|
||||
else:
|
||||
raise ConfigurationError(f"未知的 API 提供商: {provider}")
|
||||
|
||||
@@ -149,6 +178,42 @@ def test_api_connection(provider: str = "anthropic") -> bool:
|
||||
max_tokens=10,
|
||||
messages=[{"role": "user", "content": "Hi"}]
|
||||
)
|
||||
elif provider == "mimo":
|
||||
# 使用 requests 直接调用
|
||||
response = requests.post(
|
||||
config["base_url"],
|
||||
headers={
|
||||
"api-key": config["api_key"],
|
||||
"Content-Type": "application/json"
|
||||
},
|
||||
json={
|
||||
"model": config["model"],
|
||||
"max_tokens": 10,
|
||||
"messages": [{"role": "user", "content": "Hi"}]
|
||||
},
|
||||
timeout=config["timeout"]
|
||||
)
|
||||
data = response.json()
|
||||
if "error" in data:
|
||||
raise Exception(data["error"])
|
||||
elif provider == "glm":
|
||||
# 智谱 GLM API 测试
|
||||
response = requests.post(
|
||||
config["base_url"],
|
||||
headers={
|
||||
"Authorization": f"Bearer {config['api_key']}",
|
||||
"Content-Type": "application/json"
|
||||
},
|
||||
json={
|
||||
"model": config["model"],
|
||||
"max_tokens": 10,
|
||||
"messages": [{"role": "user", "content": "Hi"}]
|
||||
},
|
||||
timeout=config["timeout"]
|
||||
)
|
||||
data = response.json()
|
||||
if "error" in data:
|
||||
raise Exception(data["error"])
|
||||
logger.info(f"API 连接测试成功: {provider}")
|
||||
return True
|
||||
except Exception as e:
|
||||
@@ -271,3 +336,130 @@ class OpenAIVision(VisionModel):
|
||||
}],
|
||||
)
|
||||
return response.choices[0].message.content
|
||||
|
||||
|
||||
class MiMoVision(VisionModel):
|
||||
"""MiMo API implementation (小米大模型，Anthropic 兼容格式)"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
api_key: Optional[str] = None,
|
||||
base_url: Optional[str] = None,
|
||||
model: Optional[str] = None,
|
||||
timeout: Optional[int] = None
|
||||
):
|
||||
config = validate_api_config("mimo")
|
||||
self.api_key = api_key or config["api_key"]
|
||||
self.base_url = base_url or config["base_url"]
|
||||
self.model = model or config["model"]
|
||||
self.timeout = timeout or config["timeout"]
|
||||
|
||||
@retry_with_backoff(max_retries=3, base_delay=1.0)
|
||||
def analyze(self, image_base64: str, prompt: str) -> str:
|
||||
"""
|
||||
调用 MiMo API 分析图片
|
||||
|
||||
MiMo 使用 Anthropic 兼容的消息格式，但使用 api-key header 认证
|
||||
"""
|
||||
response = requests.post(
|
||||
self.base_url,
|
||||
headers={
|
||||
"api-key": self.api_key,
|
||||
"Content-Type": "application/json"
|
||||
},
|
||||
json={
|
||||
"model": self.model,
|
||||
"max_tokens": 4096,
|
||||
"temperature": 0.3,
|
||||
"stream": False,
|
||||
"messages": [{
|
||||
"role": "user",
|
||||
"content": [
|
||||
{
|
||||
"type": "image",
|
||||
"source": {
|
||||
"type": "base64",
|
||||
"media_type": "image/png",
|
||||
"data": image_base64,
|
||||
},
|
||||
},
|
||||
{"type": "text", "text": prompt}
|
||||
],
|
||||
}],
|
||||
},
|
||||
timeout=self.timeout
|
||||
)
|
||||
|
||||
data = response.json()
|
||||
|
||||
# 检查错误
|
||||
if "error" in data:
|
||||
raise Exception(f"MiMo API 错误: {data['error']}")
|
||||
|
||||
# 提取响应文本
|
||||
if data.get("content"):
|
||||
return data["content"][0]["text"]
|
||||
else:
|
||||
raise Exception(f"MiMo API 响应格式异常: {data}")
|
||||
|
||||
|
||||
class GLMVision(VisionModel):
|
||||
"""智谱 GLM-4.6V-Flash API implementation (OpenAI 兼容格式)"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
api_key: Optional[str] = None,
|
||||
base_url: Optional[str] = None,
|
||||
model: Optional[str] = None,
|
||||
timeout: Optional[int] = None
|
||||
):
|
||||
config = validate_api_config("glm")
|
||||
self.api_key = api_key or config["api_key"]
|
||||
self.base_url = base_url or config["base_url"]
|
||||
self.model = model or config["model"]
|
||||
self.timeout = timeout or config["timeout"]
|
||||
|
||||
@retry_with_backoff(max_retries=3, base_delay=1.0)
|
||||
def analyze(self, image_base64: str, prompt: str) -> str:
|
||||
"""
|
||||
调用智谱 GLM API 分析图片
|
||||
|
||||
GLM 使用 OpenAI 兼容格式，支持 image_url 类型（包括 base64 data URI）
|
||||
"""
|
||||
response = requests.post(
|
||||
self.base_url,
|
||||
headers={
|
||||
"Authorization": f"Bearer {self.api_key}",
|
||||
"Content-Type": "application/json"
|
||||
},
|
||||
json={
|
||||
"model": self.model,
|
||||
"max_tokens": 4096,
|
||||
"temperature": 0.3,
|
||||
"messages": [{
|
||||
"role": "user",
|
||||
"content": [
|
||||
{
|
||||
"type": "image_url",
|
||||
"image_url": {
|
||||
"url": f"data:image/png;base64,{image_base64}"
|
||||
}
|
||||
},
|
||||
{"type": "text", "text": prompt}
|
||||
],
|
||||
}],
|
||||
},
|
||||
timeout=self.timeout
|
||||
)
|
||||
|
||||
data = response.json()
|
||||
|
||||
# 检查错误
|
||||
if "error" in data:
|
||||
raise Exception(f"GLM API 错误: {data['error']}")
|
||||
|
||||
# 提取响应文本 (OpenAI 格式)
|
||||
if data.get("choices"):
|
||||
return data["choices"][0]["message"]["content"]
|
||||
else:
|
||||
raise Exception(f"GLM API 响应格式异常: {data}")
|
||||
|
||||
188
tests/README.md
Normal file
188
tests/README.md
Normal file
@@ -0,0 +1,188 @@
|
||||
# 通用 Web 测试框架使用指南
|
||||
|
||||
## 概述
|
||||
|
||||
这个通用测试框架可以测试任意网站，不再局限于特定系统。支持多种测试模式和配置方式。
|
||||
|
||||
## 快速开始
|
||||
|
||||
### 1. 最简单的使用方式
|
||||
|
||||
```bash
|
||||
# 测试任意网站（默认使用 claude 模型）
|
||||
python tests/quick_test.py https://github.com
|
||||
|
||||
# 使用其他模型
|
||||
python tests/quick_test.py https://github.com --model glm
|
||||
|
||||
# 无头模式（不显示浏览器窗口）
|
||||
python tests/quick_test.py https://github.com --headless
|
||||
|
||||
# 限制点击次数
|
||||
python tests/quick_test.py https://github.com --max-clicks 20
|
||||
|
||||
# 需要登录的测试
|
||||
python tests/quick_test.py https://example.com --login --username user@example.com --password yourpassword
|
||||
```
|
||||
|
||||
### 2. 使用配置文件
|
||||
|
||||
#### JSON 配置示例
|
||||
|
||||
```bash
|
||||
# 使用 JSON 配置文件
|
||||
python tests/universal_tester.py --config tests/configs/github_example.json
|
||||
```
|
||||
|
||||
#### YAML 配置示例
|
||||
|
||||
```bash
|
||||
# 使用 YAML 配置文件
|
||||
python tests/universal_tester.py --config tests/configs/enterprise_system.yaml
|
||||
```
|
||||
|
||||
### 3. 命令行参数
|
||||
|
||||
```bash
|
||||
python tests/universal_tester.py --url https://example.com --mode explore --model claude --headless --output report.json
|
||||
```
|
||||
|
||||
## 配置文件格式
|
||||
|
||||
### 基本配置
|
||||
|
||||
```json
|
||||
{
|
||||
"name": "测试名称",
|
||||
"url": "https://example.com",
|
||||
"mode": "explore", // explore, goal, hybrid
|
||||
"model": "claude", // claude, openai, glm, mimo
|
||||
"headless": true
|
||||
}
|
||||
```
|
||||
|
||||
### 登录配置
|
||||
|
||||
```json
|
||||
{
|
||||
"login": {
|
||||
"url": "https://example.com/login",
|
||||
"username": "user@example.com",
|
||||
"password": "password",
|
||||
"username_field": "email",
|
||||
"password_field": "password",
|
||||
"submit_button": "登录"
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### 探索配置
|
||||
|
||||
```json
|
||||
{
|
||||
"explore_config": {
|
||||
"max_depth": 20,
|
||||
"max_clicks": 100,
|
||||
"focus_patterns": ["管理", "设置", "新增"],
|
||||
"dangerous_patterns": ["删除", "退出", "注销"]
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### 混合模式步骤
|
||||
|
||||
```json
|
||||
{
|
||||
"mode": "hybrid",
|
||||
"steps": [
|
||||
{"action": "goal", "goal": "点击登录按钮"},
|
||||
{"action": "wait", "duration": 2000},
|
||||
{"action": "explore", "config": {"max_clicks": 10}},
|
||||
{"action": "verify", "target": "显示登录成功"}
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
### 验证规则
|
||||
|
||||
```json
|
||||
{
|
||||
"verifications": [
|
||||
{"type": "url_contains", "value": "/dashboard"},
|
||||
{"type": "element_exists", "value": ".user-profile"},
|
||||
{"type": "text_contains", "value": "欢迎"}
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
## 测试模式说明
|
||||
|
||||
### 1. Explore 模式（探索模式）
|
||||
- AI 自动探索页面功能
|
||||
- 发现可交互元素
|
||||
- 适合了解新网站
|
||||
|
||||
### 2. Goal 模式（目标模式）
|
||||
- 执行特定目标
|
||||
- 适合单一任务测试
|
||||
|
||||
### 3. Hybrid 模式（混合模式）
|
||||
- 结合目标导向和智能探索
|
||||
- 支持多步骤业务流程测试
|
||||
|
||||
## 实际使用示例
|
||||
|
||||
### 测试 GitHub
|
||||
|
||||
```bash
|
||||
# 快速测试
|
||||
python tests/quick_test.py https://github.com --headless
|
||||
|
||||
# 使用配置文件
|
||||
python tests/universal_tester.py --config tests/configs/github_example.json
|
||||
```
|
||||
|
||||
### 测试企业系统
|
||||
|
||||
```yaml
|
||||
# enterprise_system.yaml
|
||||
name: 企业系统测试
|
||||
url: "https://your-system.com"
|
||||
mode: hybrid
|
||||
login:
|
||||
username: "test@company.com"
|
||||
password: "password"
|
||||
steps:
|
||||
- action: goal
|
||||
goal: "点击登录按钮"
|
||||
- action: explore
|
||||
config:
|
||||
max_clicks: 20
|
||||
```
|
||||
|
||||
```bash
|
||||
python tests/universal_tester.py --config enterprise_system.yaml
|
||||
```
|
||||
|
||||
## 报告输出
|
||||
|
||||
测试完成后会生成详细的测试报告，包括：
|
||||
- 测试步骤
|
||||
- 发现的元素
|
||||
- 错误信息
|
||||
- 验证结果
|
||||
|
||||
## 注意事项
|
||||
|
||||
1. **登录信息**：不要在配置文件中硬编码敏感信息，建议使用命令行参数或环境变量
|
||||
2. **网站兼容性**：不同网站可能需要调整定位策略
|
||||
3. **测试频率**：避免过于频繁的测试，以免被网站封禁
|
||||
4. **法律合规**：确保你有权限测试目标网站
|
||||
|
||||
## 扩展开发
|
||||
|
||||
如需添加自定义功能，可以：
|
||||
1. 继承 `UniversalWebTester` 类
|
||||
2. 添加新的验证类型
|
||||
3. 扩展配置选项
|
||||
4. 自定义报告格式
|
||||
149
tests/auto_test.py
Normal file
149
tests/auto_test.py
Normal file
@@ -0,0 +1,149 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
零配置智能测试 - 无需预先了解系统功能
|
||||
"""
|
||||
|
||||
import sys
|
||||
sys.path.insert(0, ".")
|
||||
|
||||
from src import WebTester
|
||||
|
||||
def auto_discover_and_test(url: str, model: str = "glm", headless: bool = False):
|
||||
"""
|
||||
自动发现并测试系统功能
|
||||
适合完全未知的系统
|
||||
"""
|
||||
|
||||
print("=" * 60)
|
||||
print("🤖 零配置智能测试")
|
||||
print("=" * 60)
|
||||
print(f"🌐 目标URL: {url}")
|
||||
print(f"🤖 AI模型: {model}")
|
||||
print(f"🖥️ 无头模式: {'是' if headless else '否'}")
|
||||
print("-" * 60)
|
||||
|
||||
tester = WebTester(model=model, headless=headless)
|
||||
|
||||
try:
|
||||
# 启动并导航
|
||||
tester.start()
|
||||
tester.goto(url)
|
||||
|
||||
# 步骤1: 智能登录（如果需要）
|
||||
print("\n📝 步骤1: 检测登录状态")
|
||||
current_url = tester.browser.page.url
|
||||
|
||||
# 简单判断是否在登录页
|
||||
if "login" in current_url.lower() or tester.browser.page.locator("input[type='password']").count() > 0:
|
||||
print(" 检测到登录页面，尝试智能登录...")
|
||||
# 尝试常见的用户名密码
|
||||
login_goals = [
|
||||
"输入用户名admin和密码password，点击登录",
|
||||
"输入admin/admin，点击登录",
|
||||
"输入test/123456，点击登录"
|
||||
]
|
||||
|
||||
login_success = False
|
||||
for goal in login_goals:
|
||||
try:
|
||||
result = tester.test(goal)
|
||||
tester.browser.wait(2000)
|
||||
new_url = tester.browser.page.url
|
||||
if new_url != current_url and "login" not in new_url.lower():
|
||||
print(f" ✅ 登录成功: {goal}")
|
||||
login_success = True
|
||||
break
|
||||
except:
|
||||
continue
|
||||
|
||||
if not login_success:
|
||||
print(" ⚠️ 自动登录失败，继续探索...")
|
||||
|
||||
# 步骤2: 全面探索
|
||||
print("\n🔍 步骤2: 开始智能探索")
|
||||
explore_config = {
|
||||
"max_depth": 3, # 适中的深度
|
||||
"max_clicks": 100, # 充足的点击
|
||||
"focus_patterns": [], # 不设限制，让AI自由发现
|
||||
"dangerous_patterns": ["删除", "退出", "注销", "delete", "logout", "exit"]
|
||||
}
|
||||
|
||||
explore_result = tester.explore(explore_config)
|
||||
|
||||
# 步骤3: 分析发现的功能
|
||||
print("\n📊 步骤3: 分析测试结果")
|
||||
action_log = explore_result.get("action_log", [])
|
||||
|
||||
# 统计功能类型
|
||||
clicked_elements = []
|
||||
forms_filled = []
|
||||
pages_visited = set()
|
||||
|
||||
for action in action_log:
|
||||
if action.get("action_taken"):
|
||||
element_name = action.get("element_name", "")
|
||||
clicked_elements.append(element_name)
|
||||
|
||||
if action.get("action_type") == "form_input":
|
||||
forms_filled.append(element_name)
|
||||
|
||||
if action.get("url_changed"):
|
||||
pages_visited.add(action.get("after_url", ""))
|
||||
|
||||
# 输出发现的功能
|
||||
print(f"\n✅ 测试完成！发现的功能:")
|
||||
print(f" 🖱️ 点击的元素: {len(clicked_elements)} 个")
|
||||
print(f" 📝 填写的表单: {len(forms_filled)} 个")
|
||||
print(f" 📄 访问的页面: {len(pages_visited)} 个")
|
||||
|
||||
# 显示主要功能模块
|
||||
if clicked_elements:
|
||||
print(f"\n🎯 主要功能模块:")
|
||||
unique_elements = list(set(clicked_elements))[:10] # 显示前10个
|
||||
for i, elem in enumerate(unique_elements, 1):
|
||||
print(f" {i}. {elem}")
|
||||
|
||||
# 生成简化报告
|
||||
report = {
|
||||
"url": url,
|
||||
"total_clicks": len(clicked_elements),
|
||||
"forms_filled": len(forms_filled),
|
||||
"pages_visited": len(pages_visited),
|
||||
"discovered_elements": unique_elements,
|
||||
"success": True
|
||||
}
|
||||
|
||||
return report
|
||||
|
||||
except Exception as e:
|
||||
print(f"\n❌ 测试失败: {e}")
|
||||
return {"success": False, "error": str(e)}
|
||||
finally:
|
||||
tester.stop()
|
||||
|
||||
def main():
|
||||
import argparse
|
||||
|
||||
parser = argparse.ArgumentParser(description="零配置智能测试工具")
|
||||
parser.add_argument("url", help="要测试的网站URL")
|
||||
parser.add_argument("--model", default="glm",
|
||||
choices=["claude", "openai", "glm", "mimo"],
|
||||
help="AI模型")
|
||||
parser.add_argument("--headless", action="store_true",
|
||||
help="无头模式")
|
||||
parser.add_argument("--output", "-o", help="保存报告到文件")
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
# 运行测试
|
||||
result = auto_discover_and_test(args.url, args.model, args.headless)
|
||||
|
||||
# 保存报告
|
||||
if args.output and result.get("success"):
|
||||
import json
|
||||
with open(args.output, 'w', encoding='utf-8') as f:
|
||||
json.dump(result, f, ensure_ascii=False, indent=2)
|
||||
print(f"\n📄 报告已保存到: {args.output}")
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
183
tests/configs/enterprise_system.yaml
Normal file
183
tests/configs/enterprise_system.yaml
Normal file
@@ -0,0 +1,183 @@
|
||||
name: 企业系统全功能测试
|
||||
url: "http://47.99.105.253:8084"
|
||||
mode: hybrid
|
||||
model: glm
|
||||
headless: false
|
||||
|
||||
login:
|
||||
username: "admin"
|
||||
password: "password"
|
||||
submit_button: "登录"
|
||||
|
||||
# 探索配置 - 全面测试所有功能
|
||||
explore_config:
|
||||
max_depth: 5 # 探索深度，确保覆盖所有层级
|
||||
max_clicks: 200 # 充足的点击次数
|
||||
focus_patterns: # 引导 AI 重点测试这些功能
|
||||
- "管理"
|
||||
- "设置"
|
||||
- "新增"
|
||||
- "编辑"
|
||||
- "查询"
|
||||
- "审核"
|
||||
- "提交"
|
||||
- "导出"
|
||||
- "详情"
|
||||
- "列表"
|
||||
dangerous_patterns: # 发现但不点击的危险操作
|
||||
- "删除"
|
||||
- "退出"
|
||||
- "注销"
|
||||
- "重置"
|
||||
- "清空"
|
||||
|
||||
# 测试步骤 - 覆盖主要业务流程
|
||||
steps:
|
||||
# 1. 登录验证
|
||||
- action: goal
|
||||
goal: "在登录页面输入用户名admin和密码password，点击登录按钮"
|
||||
- action: wait
|
||||
duration: 2000
|
||||
- action: verify
|
||||
target: "成功登录并进入系统主页"
|
||||
|
||||
# 2. 测试主导航菜单
|
||||
- action: goal
|
||||
goal: "点击立项论证管理菜单"
|
||||
- action: wait
|
||||
duration: 1000
|
||||
- action: verify
|
||||
target: "成功进入立项论证管理页面"
|
||||
|
||||
# 3. 测试列表和详情
|
||||
- action: goal
|
||||
goal: "点击项目输入子菜单"
|
||||
- action: wait
|
||||
duration: 1000
|
||||
- action: goal
|
||||
goal: "点击1技术协议及科研合同评审记录"
|
||||
- action: verify
|
||||
target: "显示技术协议列表"
|
||||
|
||||
# 4. 测试表单功能
|
||||
- action: goal
|
||||
goal: "点击新增按钮"
|
||||
- action: explore
|
||||
config:
|
||||
max_clicks: 30 # 充分测试表单填写
|
||||
max_depth: 1
|
||||
- action: verify
|
||||
target: "表单成功提交并显示成功提示"
|
||||
|
||||
# 5. 测试产品方案管理
|
||||
- action: goal
|
||||
goal: "点击产品方案管理菜单"
|
||||
- action: wait
|
||||
duration: 1000
|
||||
- action: goal
|
||||
goal: "展开研制方案子菜单"
|
||||
- action: wait
|
||||
duration: 1000
|
||||
- action: goal
|
||||
goal: "点击研制方案菜单项"
|
||||
- action: explore
|
||||
config:
|
||||
max_clicks: 20
|
||||
max_depth: 2
|
||||
- action: verify
|
||||
target: "成功进入研制方案页面"
|
||||
|
||||
# 6. 测试其他管理模块
|
||||
- action: goal
|
||||
goal: "点击产品初样管理"
|
||||
- action: explore
|
||||
config:
|
||||
max_clicks: 15
|
||||
max_depth: 1
|
||||
- action: goal
|
||||
goal: "点击产品正样管理"
|
||||
- action: explore
|
||||
config:
|
||||
max_clicks: 15
|
||||
max_depth: 1
|
||||
- action: goal
|
||||
goal: "点击产品定型管理"
|
||||
- action: explore
|
||||
config:
|
||||
max_clicks: 15
|
||||
max_depth: 1
|
||||
|
||||
# 7. 测试系统管理功能
|
||||
- action: goal
|
||||
goal: "点击系统管理菜单"
|
||||
- action: explore
|
||||
config:
|
||||
max_clicks: 20
|
||||
max_depth: 2
|
||||
focus_patterns: ["用户", "角色", "权限", "日志"]
|
||||
|
||||
# 8. 测试待办事项和审批
|
||||
- action: goal
|
||||
goal: "点击待办事项"
|
||||
- action: wait
|
||||
duration: 1000
|
||||
- action: goal
|
||||
goal: "点击最新的待办记录"
|
||||
- action: explore
|
||||
config:
|
||||
max_clicks: 15
|
||||
max_depth: 1
|
||||
- action: verify
|
||||
target: "成功查看待办详情"
|
||||
|
||||
# 9. 测试搜索和筛选
|
||||
- action: goal
|
||||
goal: "在列表页面查找搜索框并输入测试内容"
|
||||
- action: explore
|
||||
config:
|
||||
max_clicks: 10
|
||||
max_depth: 1
|
||||
|
||||
# 10. 测试导出功能
|
||||
- action: goal
|
||||
goal: "查找并点击导出按钮（如果存在）"
|
||||
- action: wait
|
||||
duration: 2000
|
||||
|
||||
# 验证规则 - 确保功能正常
|
||||
verifications:
|
||||
# 登录成功验证
|
||||
- type: url_not_contains
|
||||
value: "/login"
|
||||
- type: text_contains
|
||||
value: "立项论证"
|
||||
|
||||
# 主要功能模块验证
|
||||
- type: element_exists
|
||||
value: ".ant-menu"
|
||||
- type: element_exists
|
||||
value: "button"
|
||||
- type: element_exists
|
||||
value: "input"
|
||||
|
||||
# 表单功能验证
|
||||
- type: element_exists
|
||||
value: "input[type='text']"
|
||||
- type: element_exists
|
||||
value: "input[type='password']"
|
||||
- type: element_exists
|
||||
value: "button:has-text('提交')"
|
||||
- type: element_exists
|
||||
value: "button:has-text('保存')"
|
||||
|
||||
# 列表功能验证
|
||||
- type: element_exists
|
||||
value: "table"
|
||||
- type: element_exists
|
||||
value: ".ant-table"
|
||||
|
||||
# 弹窗功能验证
|
||||
- type: element_exists
|
||||
value: ".ant-modal"
|
||||
- type: element_exists
|
||||
value: ".ant-drawer"
|
||||
23
tests/configs/github_example.json
Normal file
23
tests/configs/github_example.json
Normal file
@@ -0,0 +1,23 @@
|
||||
{
|
||||
"name": "GitHub 探索测试",
|
||||
"url": "https://github.com",
|
||||
"mode": "explore",
|
||||
"model": "claude",
|
||||
"headless": true,
|
||||
"explore_config": {
|
||||
"max_depth": 10,
|
||||
"max_clicks": 50,
|
||||
"focus_patterns": ["repository", "code", "pull request", "issue"],
|
||||
"dangerous_patterns": ["delete", "remove", "sign out"]
|
||||
},
|
||||
"verifications": [
|
||||
{
|
||||
"type": "element_exists",
|
||||
"value": "header[role='banner']"
|
||||
},
|
||||
{
|
||||
"type": "text_contains",
|
||||
"value": "Where the world builds software"
|
||||
}
|
||||
]
|
||||
}
|
||||
11
tests/configs/simple_test.yaml
Normal file
11
tests/configs/simple_test.yaml
Normal file
@@ -0,0 +1,11 @@
|
||||
# 极简测试配置 - 适合未知系统
|
||||
name: 快速功能测试
|
||||
url: "http://47.99.105.253:8084"
|
||||
mode: explore # 只用探索模式，让AI自由发现
|
||||
|
||||
# 简单的探索配置
|
||||
explore_config:
|
||||
max_depth: 30 # 适中的深度
|
||||
max_clicks: 2000 # 快速测试
|
||||
# 不设置 focus_patterns，让AI自由发现
|
||||
dangerous_patterns: ["退出", "注销"] # 只避开危险操作
|
||||
32
tests/configs/smart_test.yaml
Normal file
32
tests/configs/smart_test.yaml
Normal file
@@ -0,0 +1,32 @@
|
||||
# 智能配置 - 自动适应登录状态
|
||||
name: 智能适应测试
|
||||
url: "http://47.99.105.253:8084"
|
||||
mode: hybrid
|
||||
model: glm
|
||||
|
||||
# 测试步骤 - 根据登录状态自动调整
|
||||
steps:
|
||||
# 步骤1: 显式登录逻辑
|
||||
- action: goal
|
||||
goal: "在用户名输入框中输入 admin，在密码输入框中输入 password，点击登录按钮"
|
||||
|
||||
# 步骤2: 确认进入首页
|
||||
- action: wait
|
||||
duration: 3000
|
||||
|
||||
# 步骤3: 深度探索后台功能
|
||||
- action: explore
|
||||
config:
|
||||
max_depth: 10
|
||||
max_clicks: 500
|
||||
# 引导 AI 关注您截图中显示的菜单
|
||||
focus_patterns: ["管理", "项目", "方案", "审核", "系统"]
|
||||
dangerous_patterns: ["退出", "注销", "删除"]
|
||||
auto_handle_login: false # 已经在第一步处理过了
|
||||
|
||||
# 验证规则 - 基础验证
|
||||
verifications:
|
||||
- type: url_not_contains
|
||||
value: "login"
|
||||
- type: text_contains
|
||||
value: "分析概览"
|
||||
85
tests/quick_test.py
Normal file
85
tests/quick_test.py
Normal file
@@ -0,0 +1,85 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
快速测试工具 - 最简单的使用方式
|
||||
"""
|
||||
|
||||
import sys
|
||||
sys.path.insert(0, ".")
|
||||
|
||||
from tests.universal_tester import TestConfig, UniversalWebTester
|
||||
|
||||
|
||||
def quick_test():
|
||||
"""快速测试函数"""
|
||||
import argparse
|
||||
|
||||
parser = argparse.ArgumentParser(description="快速 Web 测试")
|
||||
parser.add_argument("url", help="要测试的网站URL")
|
||||
parser.add_argument("--model", "-m", default="claude",
|
||||
choices=["claude", "openai", "glm", "mimo"],
|
||||
help="AI模型 (默认: claude)")
|
||||
parser.add_argument("--headless", action="store_true",
|
||||
help="无头模式运行")
|
||||
parser.add_argument("--max-clicks", type=int, default=50,
|
||||
help="最大点击次数 (默认: 50)")
|
||||
parser.add_argument("--login", action="store_true",
|
||||
help="是否需要登录")
|
||||
parser.add_argument("--username", help="登录用户名")
|
||||
parser.add_argument("--password", help="登录密码")
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
# 创建配置
|
||||
config = TestConfig(
|
||||
url=args.url,
|
||||
name=f"快速测试_{args.url}",
|
||||
mode="explore",
|
||||
model=args.model,
|
||||
headless=args.headless,
|
||||
explore_config={
|
||||
"max_depth": 10,
|
||||
"max_clicks": args.max_clicks,
|
||||
"focus_patterns": [],
|
||||
"dangerous_patterns": ["删除", "delete", "退出", "exit", "注销", "logout", "sign out"]
|
||||
}
|
||||
)
|
||||
|
||||
# 添加登录配置
|
||||
if args.login and args.username and args.password:
|
||||
config.login = {
|
||||
"username": args.username,
|
||||
"password": args.password
|
||||
}
|
||||
|
||||
print(f"\n🚀 开始测试: {args.url}")
|
||||
print(f"📊 模式: 探索模式")
|
||||
print(f"🤖 AI模型: {args.model}")
|
||||
print(f"🖥️ 无头模式: {'是' if args.headless else '否'}")
|
||||
print(f"🖱️ 最大点击: {args.max_clicks}")
|
||||
print("="*50)
|
||||
|
||||
# 运行测试
|
||||
tester = UniversalWebTester(config)
|
||||
result = tester.run()
|
||||
|
||||
# 输出结果
|
||||
print("\n" + "="*50)
|
||||
print(f"✅ 测试完成!")
|
||||
print(f"📊 状态: {'通过' if result['status'] == 'passed' else '失败'}")
|
||||
|
||||
if result['steps']:
|
||||
explore_step = result['steps'][0]
|
||||
if explore_step.get('action') == 'explore':
|
||||
explore_result = explore_step.get('result', {})
|
||||
print(f"🖱️ 点击次数: {explore_result.get('click_count', 0)}")
|
||||
print(f"🔍 发现元素: {explore_result.get('discovered_elements', 0)}")
|
||||
print(f"🐛 发现问题: {explore_result.get('bugs_found', 0)}")
|
||||
|
||||
if result['errors']:
|
||||
print("\n❌ 错误信息:")
|
||||
for error in result['errors']:
|
||||
print(f" • {error}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
quick_test()
|
||||
205
tests/smart_test.py
Normal file
205
tests/smart_test.py
Normal file
@@ -0,0 +1,205 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
增强的零配置测试 - 支持无AI模式
|
||||
"""
|
||||
|
||||
import sys
|
||||
sys.path.insert(0, ".")
|
||||
|
||||
from src import WebTester
|
||||
import time
|
||||
|
||||
def smart_test(url: str, model: str = "glm", headless: bool = False, auto_login: bool = True):
|
||||
"""
|
||||
智能测试，即使AI失败也能继续
|
||||
"""
|
||||
|
||||
print("=" * 60)
|
||||
print("🤖 增强智能测试")
|
||||
print("=" * 60)
|
||||
print(f"🌐 目标URL: {url}")
|
||||
print(f"🤖 AI模型: {model}")
|
||||
print(f"🖥️ 无头模式: {'是' if headless else '否'}")
|
||||
print(f"🔐 自动登录: {'是' if auto_login else '否'}")
|
||||
print("-" * 60)
|
||||
|
||||
tester = WebTester(model=model, headless=headless)
|
||||
|
||||
try:
|
||||
# 启动并导航
|
||||
tester.start()
|
||||
tester.goto(url)
|
||||
time.sleep(2) # 等待页面加载
|
||||
|
||||
# 步骤1: 处理登录
|
||||
current_url = tester.browser.page.url
|
||||
print(f"\n📍 当前URL: {current_url}")
|
||||
|
||||
# 检查是否需要登录
|
||||
need_login = ("login" in current_url.lower() or
|
||||
tester.browser.page.locator("input[type='password']").count() > 0)
|
||||
|
||||
if need_login and auto_login:
|
||||
print("\n🔐 检测到登录页面，尝试登录...")
|
||||
|
||||
# 方法1: 尝试AI登录（如果API可用）
|
||||
login_success = False
|
||||
try:
|
||||
result = tester.test("输入用户名admin和密码password，点击登录按钮")
|
||||
time.sleep(3)
|
||||
new_url = tester.browser.page.url
|
||||
if new_url != current_url and "login" not in new_url.lower():
|
||||
print(" ✅ AI登录成功")
|
||||
login_success = True
|
||||
except Exception as e:
|
||||
print(f" ⚠️ AI登录失败: {str(e)[:50]}...")
|
||||
|
||||
# 方法2: 如果AI失败，使用DOM直接登录
|
||||
if not login_success:
|
||||
print(" 🔄 尝试直接登录...")
|
||||
try:
|
||||
# 查找用户名和密码输入框
|
||||
page = tester.browser.page
|
||||
|
||||
# 尝试多种可能的用户名输入框
|
||||
username_selectors = [
|
||||
"input[placeholder*='用户名']",
|
||||
"input[placeholder*='账号']",
|
||||
"input[name='username']",
|
||||
"input[name='account']",
|
||||
"input[type='text']"
|
||||
]
|
||||
|
||||
username_input = None
|
||||
for selector in username_selectors:
|
||||
if page.locator(selector).count() > 0:
|
||||
username_input = page.locator(selector).first
|
||||
break
|
||||
|
||||
# 尝试多种可能的密码输入框
|
||||
password_selectors = [
|
||||
"input[type='password']",
|
||||
"input[placeholder*='密码']",
|
||||
"input[name='password']"
|
||||
]
|
||||
|
||||
password_input = None
|
||||
for selector in password_selectors:
|
||||
if page.locator(selector).count() > 0:
|
||||
password_input = page.locator(selector).first
|
||||
break
|
||||
|
||||
# 填写并提交
|
||||
if username_input and password_input:
|
||||
username_input.fill("admin")
|
||||
password_input.fill("password")
|
||||
|
||||
# 查找登录按钮
|
||||
login_selectors = [
|
||||
"button:has-text('登录')",
|
||||
"button:has-text('登陆')",
|
||||
"button:has-text('确定')",
|
||||
"input[type='submit']",
|
||||
".login-btn"
|
||||
]
|
||||
|
||||
for selector in login_selectors:
|
||||
if page.locator(selector).count() > 0:
|
||||
page.locator(selector).first.click()
|
||||
break
|
||||
|
||||
time.sleep(3)
|
||||
new_url = tester.browser.page.url
|
||||
if new_url != current_url:
|
||||
print(" ✅ 直接登录成功")
|
||||
login_success = True
|
||||
except Exception as e:
|
||||
print(f" ❌ 直接登录失败: {e}")
|
||||
|
||||
if not login_success:
|
||||
print(" ⚠️ 无法自动登录，将测试登录页面功能")
|
||||
|
||||
# 步骤2: 开始探索
|
||||
print("\n🔍 开始智能探索...")
|
||||
|
||||
# 根据是否登录成功调整探索策略
|
||||
if login_success:
|
||||
explore_config = {
|
||||
"max_depth": 5,
|
||||
"max_clicks": 100,
|
||||
"focus_patterns": ["管理", "查询", "新增", "详情"],
|
||||
"dangerous_patterns": ["删除", "退出", "注销"]
|
||||
}
|
||||
else:
|
||||
explore_config = {
|
||||
"max_depth": 2,
|
||||
"max_clicks": 20,
|
||||
"focus_patterns": ["登录", "用户", "密码"],
|
||||
"dangerous_patterns": []
|
||||
}
|
||||
|
||||
# 尝试AI探索，如果失败则使用DOM探索
|
||||
try:
|
||||
explore_result = tester.explore(explore_config)
|
||||
print(" ✅ AI探索完成")
|
||||
except Exception as e:
|
||||
print(f" ⚠️ AI探索失败: {str(e)[:50]}...")
|
||||
print(" 🔄 使用基础探索...")
|
||||
|
||||
# 基础探索：点击所有可见的按钮和链接
|
||||
page = tester.browser.page
|
||||
clickable_elements = page.locator("button, a, [role='button'], input[type='button']")
|
||||
|
||||
clicked_count = 0
|
||||
for i in range(min(clickable_elements.count(), 10)):
|
||||
try:
|
||||
element = clickable_elements.nth(i)
|
||||
if element.is_visible():
|
||||
text = element.inner_text()[:20]
|
||||
print(f" 点击: {text or '无文本'}")
|
||||
element.click()
|
||||
time.sleep(1)
|
||||
page.go_back()
|
||||
time.sleep(1)
|
||||
clicked_count += 1
|
||||
except:
|
||||
continue
|
||||
|
||||
print(f" 📊 基础探索完成，点击了 {clicked_count} 个元素")
|
||||
|
||||
# 步骤3: 生成测试报告
|
||||
print("\n📊 测试总结:")
|
||||
print(f" ✅ 测试完成")
|
||||
print(f" 📄 已访问页面: {tester.browser.page.url}")
|
||||
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
print(f"\n❌ 测试失败: {e}")
|
||||
import traceback
|
||||
traceback.print_exc()
|
||||
return False
|
||||
finally:
|
||||
tester.stop()
|
||||
|
||||
def main():
|
||||
import argparse
|
||||
|
||||
parser = argparse.ArgumentParser(description="增强智能测试工具")
|
||||
parser.add_argument("url", help="要测试的网站URL")
|
||||
parser.add_argument("--model", default="glm",
|
||||
choices=["claude", "openai", "glm", "mimo"],
|
||||
help="AI模型")
|
||||
parser.add_argument("--headless", action="store_true",
|
||||
help="无头模式")
|
||||
parser.add_argument("--no-login", action="store_true",
|
||||
help="跳过自动登录")
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
# 运行测试
|
||||
success = smart_test(args.url, args.model, args.headless, not args.no_login)
|
||||
sys.exit(0 if success else 1)
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -9,6 +9,233 @@ from src import WebTester
|
||||
from concurrent.futures import ThreadPoolExecutor, as_completed
|
||||
from typing import List, Dict, Any
|
||||
import time
|
||||
import re
|
||||
|
||||
|
||||
def _ensure_sidebar_open(tester: WebTester) -> None:
|
||||
try:
|
||||
page = tester.browser.page
|
||||
if not page:
|
||||
return
|
||||
|
||||
# 检查是否已有侧边栏文本可见
|
||||
markers = ("立项论证管理", "产品方案管理", "基础数据")
|
||||
visible = False
|
||||
for marker in markers:
|
||||
try:
|
||||
# 检查是否至少有一个 marker 在页面上可见
|
||||
loc = page.get_by_text(marker, exact=False)
|
||||
if loc.count() > 0 and any(loc.nth(i).is_visible() for i in range(loc.count())):
|
||||
visible = True
|
||||
break
|
||||
except Exception:
|
||||
continue
|
||||
|
||||
if visible:
|
||||
return
|
||||
|
||||
print(" 📂 侧边栏未发现，尝试点击菜单切换按钮...")
|
||||
# 尝试点击左上角的常见切换图标位置，或者特定的菜单按钮
|
||||
toggle_selectors = [
|
||||
".anticon-menu-fold", ".anticon-menu-unfold",
|
||||
".el-icon-menu", ".toggle-sidebar",
|
||||
".ant-layout-sider-trigger"
|
||||
]
|
||||
|
||||
found_toggle = False
|
||||
for sel in toggle_selectors:
|
||||
try:
|
||||
btn = page.locator(sel)
|
||||
if btn.count() > 0 and btn.first.is_visible():
|
||||
btn.first.click()
|
||||
found_toggle = True
|
||||
break
|
||||
except Exception:
|
||||
continue
|
||||
|
||||
if not found_toggle:
|
||||
# 记录尝试点击坐标
|
||||
tester.browser.click_at(30, 30)
|
||||
tester.browser.wait(500)
|
||||
tester.browser.click_at(80, 25) # 顶部面包屑左侧
|
||||
|
||||
tester.browser.wait(1500)
|
||||
except Exception:
|
||||
return
|
||||
|
||||
|
||||
def _is_logged_in(tester: WebTester) -> bool:
|
||||
try:
|
||||
page = tester.browser.page
|
||||
if not page:
|
||||
return False
|
||||
url = (page.url or "").lower()
|
||||
if "#/auth/login" in url or "/auth/login" in url or "login" in url:
|
||||
return False
|
||||
|
||||
# DOM marker: if login form is present, consider not logged-in even if URL doesn't include login
|
||||
try:
|
||||
if page.locator("input[type='password']").count() > 0:
|
||||
if page.get_by_text("登录", exact=False).count() > 0:
|
||||
return False
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
for marker in ("分析概览", "待办事项", "系统管理"):
|
||||
try:
|
||||
if page.get_by_text(marker, exact=False).count() > 0:
|
||||
return True
|
||||
except Exception:
|
||||
continue
|
||||
|
||||
# If we can't find dashboard markers, fall back to a weaker heuristic
|
||||
try:
|
||||
if page.locator("input[type='password']").count() > 0:
|
||||
return False
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
return True
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
|
||||
def _do_login_dom(tester: WebTester, username: str = "admin", password: str = "password") -> bool:
|
||||
page = tester.browser.page
|
||||
if not page:
|
||||
return False
|
||||
|
||||
try:
|
||||
user_locators = [
|
||||
"input[placeholder*='用户']",
|
||||
"input[placeholder*='账号']",
|
||||
"input[name*='user' i]",
|
||||
"input[name*='account' i]",
|
||||
]
|
||||
pwd_locators = [
|
||||
"input[type='password']",
|
||||
"input[placeholder*='密码']",
|
||||
]
|
||||
|
||||
user_el = None
|
||||
for sel in user_locators:
|
||||
loc = page.locator(sel)
|
||||
if loc.count() > 0:
|
||||
user_el = loc.first
|
||||
break
|
||||
if user_el is None:
|
||||
# fall back to the first visible text input
|
||||
loc = page.locator("input[type='text'], input:not([type])")
|
||||
if loc.count() > 0:
|
||||
user_el = loc.first
|
||||
|
||||
pwd_el = None
|
||||
for sel in pwd_locators:
|
||||
loc = page.locator(sel)
|
||||
if loc.count() > 0:
|
||||
pwd_el = loc.first
|
||||
break
|
||||
|
||||
if user_el is None or pwd_el is None:
|
||||
return False
|
||||
|
||||
user_el.fill(username)
|
||||
pwd_el.fill(password)
|
||||
|
||||
clicked = False
|
||||
for text in ("登录", "登 录"):
|
||||
try:
|
||||
btn = page.get_by_role("button", name=re.compile(text))
|
||||
if btn.count() > 0:
|
||||
btn.first.click()
|
||||
clicked = True
|
||||
break
|
||||
except Exception:
|
||||
pass
|
||||
try:
|
||||
btn = page.get_by_text(text, exact=False)
|
||||
if btn.count() > 0:
|
||||
btn.first.click()
|
||||
clicked = True
|
||||
break
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
if not clicked:
|
||||
return False
|
||||
|
||||
tester.browser.wait_for_load_state("networkidle", timeout=15000)
|
||||
for _ in range(20):
|
||||
if _is_logged_in(tester):
|
||||
return True
|
||||
tester.browser.wait(500)
|
||||
return _is_logged_in(tester)
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
|
||||
def _ensure_logged_in(tester: WebTester, login_goal: str = "填入账号admin 密码password，登录成功") -> bool:
|
||||
if _is_logged_in(tester):
|
||||
return True
|
||||
|
||||
if _do_login_dom(tester):
|
||||
return True
|
||||
|
||||
try:
|
||||
tester.test(login_goal)
|
||||
tester.browser.wait(1500)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
return _is_logged_in(tester)
|
||||
|
||||
|
||||
def _run_hybrid_steps(tester: WebTester, steps: List[Dict[str, Any]]) -> Dict[str, Any]:
|
||||
step_results: List[Dict[str, Any]] = []
|
||||
for idx, step in enumerate(steps, 1):
|
||||
action = step.get("action")
|
||||
if action == "goal":
|
||||
_ensure_sidebar_open(tester)
|
||||
before_url = tester.browser.page.url
|
||||
r = tester.test(step.get("goal", ""))
|
||||
after_url = tester.browser.page.url
|
||||
step_results.append({
|
||||
"step": idx,
|
||||
"action": action,
|
||||
"goal": step.get("goal", ""),
|
||||
"result": r,
|
||||
"url_changed": before_url != after_url
|
||||
})
|
||||
|
||||
all_passed = all(x.get("success", False) for x in r.get("results", []))
|
||||
|
||||
# 记录警告
|
||||
if not after_url or before_url == after_url:
|
||||
if any(kw in step.get("goal", "") for kw in ("点击菜单", "跳转", "进入", "研制方案", "项目")):
|
||||
print(f" ⚠️ 警告: 执行 '{step.get('goal', '')}' 后 URL 似乎没有变化")
|
||||
|
||||
if not all_passed:
|
||||
return {"passed": False, "step_results": step_results}
|
||||
elif action == "explore":
|
||||
_ensure_sidebar_open(tester)
|
||||
try:
|
||||
r = tester.explore(step.get("config", {}))
|
||||
step_results.append({"step": idx, "action": action, "result": r})
|
||||
# 如果探索过程中没有任何操作成功，或者发生了严重错误，可以考虑判定为失败
|
||||
if not r.get("action_log") and not r.get("discovered_elements"):
|
||||
return {"passed": False, "step_results": step_results, "error": "探索未发现任何元素或未执行任何操作"}
|
||||
except Exception as e:
|
||||
step_results.append({"step": idx, "action": action, "error": str(e)})
|
||||
return {"passed": False, "step_results": step_results, "error": str(e)}
|
||||
elif action == "wait":
|
||||
duration = step.get("duration", 1000)
|
||||
tester.browser.wait(duration)
|
||||
step_results.append({"step": idx, "action": action, "duration": duration, "result": {"success": True}})
|
||||
else:
|
||||
step_results.append({"step": idx, "action": action, "result": {"success": False, "error": f"unknown action: {action}"}})
|
||||
return {"passed": False, "step_results": step_results}
|
||||
|
||||
return {"passed": True, "step_results": step_results}
|
||||
|
||||
|
||||
# ============================================================
|
||||
@@ -16,29 +243,66 @@ import time
|
||||
# ============================================================
|
||||
|
||||
TEST_CASES = [
|
||||
# 目标模式: 执行指定目标
|
||||
{
|
||||
"name": "登录",
|
||||
"url": "http://47.99.105.253:8084",
|
||||
"mode": "goal", # 目标驱动模式
|
||||
"goal": "填入账号admin 密码password，登录成功",
|
||||
},
|
||||
|
||||
# 探索模式: AI 自主发现功能
|
||||
{
|
||||
"name": "功能探索",
|
||||
"name": "登录后深度探索",
|
||||
"url": "http://47.99.105.253:8084",
|
||||
"mode": "explore", # 探索模式
|
||||
"mode": "explore",
|
||||
"config": {
|
||||
"max_depth": 3,
|
||||
"max_clicks": 30,
|
||||
"dangerous_patterns": ["删除", "移除", "退出", "注销"], # 记录但不执行
|
||||
"require_login": { # 需要先登录
|
||||
"max_depth": 20, # 探索深度
|
||||
"max_clicks": 2000, # 总点击次数
|
||||
"require_login": { # 探索前的先决条件：登录
|
||||
"goal": "填入账号admin 密码password，登录成功"
|
||||
}
|
||||
},
|
||||
"focus_patterns": ["管理", "设置", "新增"], # 引导 AI 重点测试这些关键词
|
||||
"dangerous_patterns": ["删除", "退出", "注销"] # 发现但不点击，防止测试中断
|
||||
}
|
||||
},
|
||||
|
||||
# 业务流程测试: 技术协议评审完整流程
|
||||
{
|
||||
"name": "技术协议评审流程测试",
|
||||
"url": "http://47.99.105.253:8084",
|
||||
"mode": "hybrid",
|
||||
"steps": [
|
||||
{"action": "goal", "goal": "点击立项论证管理菜单"},
|
||||
{"action": "goal", "goal": "点击项目输入子菜单"},
|
||||
{"action": "goal", "goal": "点击1技术协议及科研合同评审记录"},
|
||||
{"action": "goal", "goal": "点击新增按钮"},
|
||||
# 切换到智能探索模式完成表单填写和提交
|
||||
{"action": "explore", "config": {"max_clicks": 30, "max_depth": 1}},
|
||||
{"action": "wait", "duration": 2000},
|
||||
{"action": "goal", "goal": "点击提交按钮"},
|
||||
{"action": "wait", "duration": 2000},
|
||||
{"action": "goal", "goal": "点击待办事项"},
|
||||
{"action": "goal", "goal": "点击最新提交的个人待办记录"},
|
||||
{"action": "goal", "goal": "点击审核/处理按钮"},
|
||||
{"action": "explore", "config": {"max_clicks": 15, "max_depth": 1}}, # 智能处理审核表单
|
||||
]
|
||||
},
|
||||
|
||||
# 业务流程测试: 产品方案管理流程
|
||||
{
|
||||
"name": "产品方案管理流程测试",
|
||||
"url": "http://47.99.105.253:8084",
|
||||
"mode": "hybrid",
|
||||
"steps": [
|
||||
{"action": "goal", "goal": "点击一级菜单'产品方案管理'"},
|
||||
{"action": "wait", "duration": 1000},
|
||||
{"action": "goal", "goal": "展开二级分类'研制方案'"},
|
||||
{"action": "wait", "duration": 1000},
|
||||
{"action": "goal", "goal": "点击菜单项'研制方案'"},
|
||||
{"action": "wait", "duration": 1000},
|
||||
{"action": "goal", "goal": "点击新增按钮"},
|
||||
# 使用探索模式完成表单填写和提交
|
||||
{"action": "explore", "config": {"max_clicks": 20, "max_depth": 1}},
|
||||
{"action": "wait", "duration": 2000},
|
||||
{"action": "goal", "goal": "点击待办事项"},
|
||||
{"action": "goal", "goal": "点击审批详情"},
|
||||
{"action": "explore", "config": {"max_clicks": 10, "max_depth": 1}},
|
||||
]
|
||||
},
|
||||
|
||||
# 混合模式: 先执行目标，再探索
|
||||
# {
|
||||
# "name": "登录后探索",
|
||||
@@ -73,6 +337,44 @@ def run_single_case(case: Dict[str, Any], model: str = "claude",
|
||||
try:
|
||||
with WebTester(model=model, headless=headless) as tester:
|
||||
tester.goto(url)
|
||||
|
||||
# Always attempt deterministic login first (single-case mode should be robust)
|
||||
_ensure_logged_in(tester)
|
||||
|
||||
# 检查是否需要登录（适用于所有模式）
|
||||
login_needed = False
|
||||
login_goal = None
|
||||
|
||||
# 检查配置中是否需要登录
|
||||
if mode == "explore":
|
||||
config = case.get("config", {})
|
||||
require_login = config.get("require_login")
|
||||
if require_login:
|
||||
login_goal = require_login.get("goal", "")
|
||||
login_needed = True
|
||||
elif mode == "hybrid":
|
||||
# 检查步骤中是否包含登录
|
||||
for step in case.get("steps", []):
|
||||
if "登录" in step.get("goal", "") or "admin" in step.get("goal", ""):
|
||||
login_needed = False # 步骤中已包含登录
|
||||
break
|
||||
else:
|
||||
# 如果步骤中没有登录，但系统可能需要登录
|
||||
login_goal = "填入账号admin 密码password，登录成功"
|
||||
login_needed = True
|
||||
elif mode == "goal":
|
||||
# 目标模式检查是否需要登录
|
||||
goal = case.get("goal", "")
|
||||
if "登录" not in goal and "admin" not in goal:
|
||||
login_goal = "填入账号admin 密码password，登录成功"
|
||||
login_needed = True
|
||||
|
||||
# 执行登录
|
||||
if login_needed and login_goal:
|
||||
if not _is_logged_in(tester):
|
||||
_ensure_logged_in(tester, login_goal)
|
||||
|
||||
_ensure_sidebar_open(tester)
|
||||
|
||||
if mode == "goal":
|
||||
# 目标模式
|
||||
@@ -103,12 +405,9 @@ def run_single_case(case: Dict[str, Any], model: str = "claude",
|
||||
|
||||
elif mode == "hybrid":
|
||||
# 混合模式
|
||||
for step in case.get("steps", []):
|
||||
if step.get("action") == "goal":
|
||||
tester.test(step["goal"])
|
||||
elif step.get("action") == "explore":
|
||||
tester.explore(step.get("config", {}))
|
||||
result["status"] = "passed"
|
||||
hybrid_res = _run_hybrid_steps(tester, case.get("steps", []))
|
||||
result["status"] = "passed" if hybrid_res.get("passed") else "failed"
|
||||
result["hybrid"] = hybrid_res
|
||||
|
||||
except Exception as e:
|
||||
result["error"] = str(e)
|
||||
@@ -116,24 +415,70 @@ def run_single_case(case: Dict[str, Any], model: str = "claude",
|
||||
return result
|
||||
|
||||
|
||||
def run_tests(model: str = "claude", headless: bool = False):
|
||||
def run_tests(model: str = "claude", headless: bool = False, cases: List[Dict[str, Any]] = None):
|
||||
"""串行运行所有测试用例"""
|
||||
results = []
|
||||
|
||||
selected_cases = cases if cases is not None else TEST_CASES
|
||||
|
||||
with WebTester(model=model, headless=headless) as tester:
|
||||
for i, case in enumerate(TEST_CASES, 1):
|
||||
for i, case in enumerate(selected_cases, 1):
|
||||
name = case.get("name", f"Test {i}")
|
||||
url = case["url"]
|
||||
mode = case.get("mode", "goal")
|
||||
|
||||
print(f"\n{'='*60}")
|
||||
print(f"🧪 [{i}/{len(TEST_CASES)}] {name}")
|
||||
print(f"🧪 [{i}/{len(selected_cases)}] {name}")
|
||||
print(f" URL: {url}")
|
||||
print(f" Mode: {mode}")
|
||||
print(f"{'='*60}")
|
||||
|
||||
try:
|
||||
tester.goto(url)
|
||||
|
||||
_ensure_logged_in(tester)
|
||||
|
||||
# 检查是否需要登录（适用于所有模式）
|
||||
login_needed = False
|
||||
login_goal = None
|
||||
|
||||
# 检查配置中是否需要登录
|
||||
if mode == "explore":
|
||||
config = case.get("config", {}).copy()
|
||||
require_login = config.pop("require_login", None)
|
||||
if require_login:
|
||||
login_goal = require_login.get("goal", "")
|
||||
login_needed = True
|
||||
elif mode == "hybrid":
|
||||
# 检查步骤中是否包含登录
|
||||
for step in case.get("steps", []):
|
||||
if "登录" in step.get("goal", "") or "admin" in step.get("goal", ""):
|
||||
login_needed = False # 步骤中已包含登录
|
||||
break
|
||||
else:
|
||||
# 如果步骤中没有登录，但系统可能需要登录
|
||||
login_goal = "填入账号admin 密码password，登录成功"
|
||||
login_needed = True
|
||||
elif mode == "goal":
|
||||
# 目标模式检查是否需要登录
|
||||
goal = case.get("goal", "")
|
||||
if "登录" not in goal and "admin" not in goal:
|
||||
login_goal = "填入账号admin 密码password，登录成功"
|
||||
login_needed = True
|
||||
|
||||
# 执行登录
|
||||
if login_needed and login_goal:
|
||||
print(f" 🔎 检查登录状态...")
|
||||
if not _is_logged_in(tester):
|
||||
ok = _ensure_logged_in(tester, login_goal)
|
||||
if ok:
|
||||
print(f" ✅ 登录成功")
|
||||
else:
|
||||
print(f" ⚠️ 登录未确认成功，继续执行")
|
||||
else:
|
||||
print(f" ✅ 已处于登录状态，跳过登录步骤")
|
||||
|
||||
_ensure_sidebar_open(tester)
|
||||
|
||||
if mode == "goal":
|
||||
goal = case.get("goal", "")
|
||||
@@ -148,6 +493,12 @@ def run_tests(model: str = "claude", headless: bool = False):
|
||||
status = "passed"
|
||||
else:
|
||||
print(f"⚠️ 部分失败: {failed_count}/{result['steps']} 步骤失败")
|
||||
first_failed = next((r for r in result.get("results", []) if not r.get("success", False)), None)
|
||||
if first_failed:
|
||||
action_type = first_failed.get("action_type") or first_failed.get("action") or "unknown"
|
||||
target = first_failed.get("target") or first_failed.get("element") or first_failed.get("description") or ""
|
||||
err = first_failed.get("error") or first_failed.get("reason") or ""
|
||||
print(f" ❌ 首个失败: {action_type} {target} {err}".strip())
|
||||
status = "failed"
|
||||
|
||||
print(f"📄 报告: {result['report']}")
|
||||
@@ -161,33 +512,101 @@ def run_tests(model: str = "claude", headless: bool = False):
|
||||
|
||||
elif mode == "explore":
|
||||
config = case.get("config", {}).copy()
|
||||
login_status = "skipped"
|
||||
login_error = None
|
||||
|
||||
# 如果需要先登录
|
||||
require_login = config.pop("require_login", None)
|
||||
if require_login:
|
||||
login_goal = require_login.get("goal", "")
|
||||
if login_goal:
|
||||
print(f" 🔐 执行登录...")
|
||||
tester.test(login_goal)
|
||||
tester.browser.wait(1000)
|
||||
try:
|
||||
# 检查是否已登录
|
||||
print(f" 🔎 检查登录状态...")
|
||||
if _is_logged_in(tester):
|
||||
print(f" ✅ 已处于登录状态，跳过登录步骤")
|
||||
login_status = "already_logged_in"
|
||||
else:
|
||||
print(f" 🔐 执行登录: {login_goal}")
|
||||
login_result = tester.test(login_goal)
|
||||
tester.browser.wait(3000)
|
||||
|
||||
# 检查登录结果
|
||||
login_success = all(r.get("success", False) for r in login_result.get("results", []))
|
||||
if login_success:
|
||||
login_status = "success"
|
||||
else:
|
||||
login_status = "partial_failure"
|
||||
# 登录部分失败，但仍继续探索
|
||||
print(f" ⚠️ 登录步骤部分失败，继续尝试探索...")
|
||||
|
||||
# 等待页面加载
|
||||
print(f" 🔎 确认登录跳转结果...")
|
||||
tester.browser.wait_for_load_state("networkidle")
|
||||
tester.browser.wait(2000)
|
||||
except Exception as e:
|
||||
login_error = str(e)
|
||||
login_status = "error"
|
||||
print(f" ⚠️ 登录过程出错: {e}，继续尝试探索...")
|
||||
|
||||
# 执行探索
|
||||
# 无论登录结果如何，都执行探索
|
||||
print(f" 🔍 开始功能探索...")
|
||||
result = tester.explore(config)
|
||||
|
||||
elements = len(result.get("discovered_elements", []))
|
||||
bugs = len(result.get("bug_list", []))
|
||||
|
||||
print(f"✅ 探索完成: 发现 {elements} 个元素, {bugs} 个问题")
|
||||
print(f"📄 报告: {result.get('report', '')}")
|
||||
|
||||
results.append({
|
||||
"name": name,
|
||||
"status": "passed",
|
||||
"elements": elements,
|
||||
"bugs": bugs,
|
||||
"report": result.get("report", ""),
|
||||
})
|
||||
try:
|
||||
result = tester.explore(config)
|
||||
|
||||
elements = len(result.get("discovered_elements", []))
|
||||
bugs = len(result.get("bug_list", []))
|
||||
|
||||
print(f"✅ 探索完成: 发现 {elements} 个元素, {bugs} 个问题")
|
||||
print(f"📄 报告: {result.get('report', '')}")
|
||||
|
||||
# 根据登录状态决定最终状态
|
||||
final_status = "passed" if login_status in ("success", "already_logged_in", "skipped") else "partial"
|
||||
|
||||
results.append({
|
||||
"name": name,
|
||||
"status": final_status,
|
||||
"login_status": login_status,
|
||||
"login_error": login_error,
|
||||
"elements": elements,
|
||||
"bugs": bugs,
|
||||
"report": result.get("report", ""),
|
||||
})
|
||||
except Exception as e:
|
||||
print(f" ❌ 探索过程出错: {e}")
|
||||
results.append({
|
||||
"name": name,
|
||||
"status": "failed",
|
||||
"login_status": login_status,
|
||||
"error": str(e),
|
||||
})
|
||||
|
||||
elif mode == "hybrid":
|
||||
try:
|
||||
hybrid_res = _run_hybrid_steps(tester, case.get("steps", []))
|
||||
status = "passed" if hybrid_res.get("passed") else "failed"
|
||||
if status != "passed":
|
||||
step_results = hybrid_res.get("step_results", [])
|
||||
last = step_results[-1] if step_results else None
|
||||
if last:
|
||||
step_idx = last.get("step")
|
||||
action = last.get("action")
|
||||
goal_txt = last.get("goal", "")
|
||||
print(f" ❌ Hybrid 失败在 step {step_idx}: {action} {goal_txt}".strip())
|
||||
results.append({
|
||||
"name": name,
|
||||
"status": status,
|
||||
"mode": "hybrid",
|
||||
"hybrid": hybrid_res,
|
||||
})
|
||||
except Exception as e:
|
||||
print(f"❌ 失败: {e}")
|
||||
results.append({
|
||||
"name": name,
|
||||
"status": "failed",
|
||||
"mode": "hybrid",
|
||||
"error": str(e),
|
||||
})
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ 失败: {e}")
|
||||
@@ -201,7 +620,7 @@ def run_tests(model: str = "claude", headless: bool = False):
|
||||
return results
|
||||
|
||||
|
||||
def run_tests_parallel(model: str = "claude", max_workers: int = 3):
|
||||
def run_tests_parallel(model: str = "claude", max_workers: int = 3, cases: List[Dict[str, Any]] = None):
|
||||
"""
|
||||
并行运行所有测试用例
|
||||
|
||||
@@ -210,17 +629,15 @@ def run_tests_parallel(model: str = "claude", max_workers: int = 3):
|
||||
max_workers: 最大并行数（默认 3）
|
||||
"""
|
||||
print(f"\n🚀 并行模式启动 (workers={max_workers})")
|
||||
print(f"📋 待执行测试: {len(TEST_CASES)} 个\n")
|
||||
selected_cases = cases if cases is not None else TEST_CASES
|
||||
print(f"📋 待执行测试: {len(selected_cases)} 个\n")
|
||||
|
||||
results = []
|
||||
start_time = time.time()
|
||||
|
||||
with ThreadPoolExecutor(max_workers=max_workers) as executor:
|
||||
# 提交所有任务
|
||||
future_to_case = {
|
||||
executor.submit(run_single_case, case, model, True): case
|
||||
for case in TEST_CASES
|
||||
}
|
||||
future_to_case = {executor.submit(run_single_case, case, model, True): case for case in selected_cases}
|
||||
|
||||
# 收集结果
|
||||
for future in as_completed(future_to_case):
|
||||
@@ -251,21 +668,57 @@ def _print_summary(results: List[Dict[str, Any]]):
|
||||
print("📊 测试总结")
|
||||
print(f"{'='*60}")
|
||||
passed = sum(1 for r in results if r["status"] == "passed")
|
||||
failed = len(results) - passed
|
||||
partial = sum(1 for r in results if r["status"] == "partial")
|
||||
failed = sum(1 for r in results if r["status"] == "failed")
|
||||
|
||||
print(f"✅ 通过: {passed}")
|
||||
if partial > 0:
|
||||
print(f"⚠️ 部分通过: {partial}")
|
||||
print(f"❌ 失败: {failed}")
|
||||
if results:
|
||||
print(f"📈 通过率: {passed/len(results)*100:.1f}%")
|
||||
# 通过率计算将 partial 视为 0.5
|
||||
rate = (passed + partial * 0.5) / len(results) * 100
|
||||
print(f"📈 通过率: {rate:.1f}%")
|
||||
|
||||
failed_cases = [r for r in results if r.get("status") == "failed"]
|
||||
if failed_cases:
|
||||
print("\n❌ 失败用例:")
|
||||
for r in failed_cases:
|
||||
name = r.get("name", "")
|
||||
report = r.get("report", "")
|
||||
err = r.get("error", "")
|
||||
line = f"- {name}"
|
||||
if report:
|
||||
line += f" | {report}"
|
||||
if err:
|
||||
line += f" | {err}"
|
||||
print(line)
|
||||
|
||||
|
||||
def run_single_test(url: str, goal: str, model: str = "claude"):
|
||||
def run_single_test(url: str, goal: str, model: str = "claude", headless: bool = False):
|
||||
"""运行单个测试"""
|
||||
with WebTester(model=model) as tester:
|
||||
tester.goto(url)
|
||||
result = tester.test(goal)
|
||||
print(f"✅ 完成: {result['steps']} 步骤")
|
||||
case = {"name": goal[:30], "url": url, "mode": "goal", "goal": goal}
|
||||
result = run_single_case(case, model=model, headless=headless)
|
||||
if result.get("status") == "passed":
|
||||
print(f"✅ 完成")
|
||||
else:
|
||||
print(f"❌ 失败: {result.get('error', 'unknown')}")
|
||||
if result.get("report"):
|
||||
print(f"📄 报告: {result['report']}")
|
||||
return result
|
||||
return result
|
||||
|
||||
|
||||
def _select_cases(args) -> List[Dict[str, Any]]:
|
||||
cases: List[Dict[str, Any]] = TEST_CASES
|
||||
if getattr(args, "index", None) is not None:
|
||||
idx = int(args.index)
|
||||
if idx < 1 or idx > len(TEST_CASES):
|
||||
raise ValueError(f"index out of range: {idx}")
|
||||
cases = [TEST_CASES[idx - 1]]
|
||||
if getattr(args, "case", None):
|
||||
q = str(args.case).strip().lower()
|
||||
cases = [c for c in cases if q in str(c.get("name", "")).lower()]
|
||||
return cases
|
||||
|
||||
|
||||
# ============================================================
|
||||
@@ -278,16 +731,26 @@ if __name__ == "__main__":
|
||||
parser = argparse.ArgumentParser(description="AI Web Tester - 测试用例运行器")
|
||||
parser.add_argument("--url", help="单个测试的 URL")
|
||||
parser.add_argument("--goal", help="单个测试的目标描述")
|
||||
parser.add_argument("--model", default="claude", choices=["claude", "openai"], help="AI 模型")
|
||||
parser.add_argument("--model", default="mimo", choices=["claude", "openai", "mimo", "glm"], help="AI 模型")
|
||||
parser.add_argument("--headless", action="store_true", help="无头模式运行")
|
||||
parser.add_argument("--parallel", action="store_true", help="并行执行测试")
|
||||
parser.add_argument("--workers", type=int, default=3, help="并行工作线程数")
|
||||
parser.add_argument("--list", action="store_true", help="列出内置测试用例")
|
||||
parser.add_argument("--case", help="按用例名子串筛选（大小写不敏感）")
|
||||
parser.add_argument("--index", type=int, help="按序号选择用例（从 1 开始，基于内置用例列表）")
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
if args.list:
|
||||
for i, c in enumerate(TEST_CASES, 1):
|
||||
print(f"[{i}] {c.get('name', '')} ({c.get('mode', 'goal')})")
|
||||
sys.exit(0)
|
||||
|
||||
selected_cases = _select_cases(args)
|
||||
|
||||
if args.url and args.goal:
|
||||
run_single_test(args.url, args.goal, args.model)
|
||||
run_single_test(args.url, args.goal, args.model, args.headless)
|
||||
elif args.parallel:
|
||||
run_tests_parallel(model=args.model, max_workers=args.workers)
|
||||
run_tests_parallel(model=args.model, max_workers=args.workers, cases=selected_cases)
|
||||
else:
|
||||
run_tests(model=args.model, headless=args.headless)
|
||||
run_tests(model=args.model, headless=args.headless, cases=selected_cases)
|
||||
|
||||
354
tests/universal_tester.py
Normal file
354
tests/universal_tester.py
Normal file
@@ -0,0 +1,354 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
通用 Web 测试框架
|
||||
支持测试任意网站
|
||||
"""
|
||||
|
||||
import sys
|
||||
import os
|
||||
import json
|
||||
import yaml
|
||||
from typing import Dict, Any, List, Optional
|
||||
from dataclasses import dataclass, field
|
||||
sys.path.insert(0, ".")
|
||||
|
||||
from src import WebTester
|
||||
|
||||
|
||||
@dataclass
|
||||
class TestConfig:
|
||||
"""测试配置"""
|
||||
url: str
|
||||
name: str = "Web Test"
|
||||
mode: str = "explore" # explore, goal, hybrid
|
||||
headless: bool = True
|
||||
model: str = "claude"
|
||||
|
||||
# 登录配置
|
||||
login: Optional[Dict[str, Any]] = None
|
||||
# 示例:
|
||||
# login: {
|
||||
# "url": "http://example.com/login",
|
||||
# "username": "user@example.com",
|
||||
# "password": "password",
|
||||
# "username_field": "email",
|
||||
# "password_field": "password",
|
||||
# "submit_button": "登录"
|
||||
# }
|
||||
|
||||
# 探索配置
|
||||
explore_config: Dict[str, Any] = field(default_factory=lambda: {
|
||||
"max_depth": 20,
|
||||
"max_clicks": 100,
|
||||
"focus_patterns": [],
|
||||
"dangerous_patterns": ["删除", "delete", "退出", "exit", "注销", "logout"]
|
||||
})
|
||||
|
||||
# 测试步骤（hybrid模式）
|
||||
steps: List[Dict[str, Any]] = field(default_factory=list)
|
||||
# 示例:
|
||||
# steps: [
|
||||
# {"action": "goal", "goal": "点击登录按钮"},
|
||||
# {"action": "explore", "config": {"max_clicks": 10}},
|
||||
# {"action": "verify", "target": "显示登录成功"}
|
||||
# ]
|
||||
|
||||
# 验证规则
|
||||
verifications: List[Dict[str, Any]] = field(default_factory=list)
|
||||
# 示例:
|
||||
# verifications: [
|
||||
# {"type": "url_contains", "value": "/dashboard"},
|
||||
# {"type": "element_exists", "selector": ".user-profile"},
|
||||
# {"type": "text_contains", "text": "欢迎"}
|
||||
# ]
|
||||
|
||||
|
||||
class UniversalWebTester:
|
||||
"""通用 Web 测试器"""
|
||||
|
||||
def __init__(self, config: TestConfig):
|
||||
self.config = config
|
||||
# 优先使用配置中的模型，如果没有则使用默认
|
||||
model_name = getattr(config, "model", "glm")
|
||||
print(f"DEBUG: Initializing WebTester with model: {model_name}")
|
||||
self.tester = WebTester(model=model_name, headless=config.headless)
|
||||
|
||||
def run(self) -> Dict[str, Any]:
|
||||
"""运行测试"""
|
||||
result = {
|
||||
"name": self.config.name,
|
||||
"url": self.config.url,
|
||||
"status": "passed",
|
||||
"steps": [],
|
||||
"errors": []
|
||||
}
|
||||
|
||||
try:
|
||||
# 启动浏览器
|
||||
self.tester.start()
|
||||
self.tester.goto(self.config.url)
|
||||
|
||||
# 处理登录
|
||||
if self.config.login:
|
||||
self._handle_login()
|
||||
|
||||
# 根据模式执行测试
|
||||
if self.config.mode == "explore":
|
||||
self._run_explore(result)
|
||||
elif self.config.mode == "goal":
|
||||
self._run_goal(result)
|
||||
elif self.config.mode == "hybrid":
|
||||
self._run_hybrid(result)
|
||||
|
||||
# 执行验证
|
||||
self._run_verifications(result)
|
||||
|
||||
except Exception as e:
|
||||
result["status"] = "failed"
|
||||
result["errors"].append(str(e))
|
||||
finally:
|
||||
# 生成汇总报告
|
||||
try:
|
||||
from src.reporter.generator import ReportGenerator
|
||||
reporter = ReportGenerator()
|
||||
report_path = reporter.generate_session_report(self.config.name, result)
|
||||
result["report_path"] = str(report_path)
|
||||
print(f"\n📊 测试报告已生成: {report_path}")
|
||||
except Exception as e:
|
||||
print(f"\n⚠️ 报告生成失败: {e}")
|
||||
|
||||
self.tester.stop()
|
||||
|
||||
return result
|
||||
|
||||
def _handle_login(self):
|
||||
"""处理登录"""
|
||||
login_config = self.config.login
|
||||
|
||||
# 如果提供了登录URL，先跳转
|
||||
if login_config.get("url"):
|
||||
self.tester.goto(login_config["url"])
|
||||
|
||||
# 构建登录目标
|
||||
username = login_config["username"]
|
||||
password = login_config["password"]
|
||||
username_field = login_config.get("username_field", "username")
|
||||
password_field = login_config.get("password_field", "password")
|
||||
submit_button = login_config.get("submit_button", "登录")
|
||||
|
||||
goal = f"在{username_field}输入框中输入{username}，在{password_field}输入框中输入{password}，点击{submit_button}按钮"
|
||||
|
||||
# 执行登录
|
||||
self.tester.test(goal)
|
||||
self.tester.browser.wait(2000)
|
||||
|
||||
def _run_explore(self, result: Dict[str, Any]):
|
||||
"""运行探索模式"""
|
||||
explore_result = self.tester.explore(self.config.explore_config)
|
||||
result["steps"].append({
|
||||
"action": "explore",
|
||||
"result": explore_result
|
||||
})
|
||||
|
||||
def _run_goal(self, result: Dict[str, Any]):
|
||||
"""运行目标模式"""
|
||||
# 这里可以添加具体的目标测试逻辑
|
||||
pass
|
||||
|
||||
def _run_hybrid(self, result: Dict[str, Any]):
|
||||
"""运行混合模式"""
|
||||
for step in self.config.steps:
|
||||
action = step.get("action")
|
||||
|
||||
if action == "goal":
|
||||
try:
|
||||
goal_result = self.tester.test(step.get("goal", ""))
|
||||
result["steps"].append({
|
||||
"action": "goal",
|
||||
"goal": step.get("goal"),
|
||||
"result": goal_result
|
||||
})
|
||||
except Exception as e:
|
||||
# 如果goal失败，记录但不中断测试
|
||||
print(f" ⚠️ 目标执行失败: {str(e)[:50]}...")
|
||||
result["steps"].append({
|
||||
"action": "goal",
|
||||
"goal": step.get("goal"),
|
||||
"result": {"success": False, "error": str(e)}
|
||||
})
|
||||
elif action == "explore":
|
||||
explore_config = step.get("config", {})
|
||||
try:
|
||||
explore_result = self.tester.explore(explore_config)
|
||||
result["steps"].append({
|
||||
"action": "explore",
|
||||
"result": explore_result
|
||||
})
|
||||
except Exception as e:
|
||||
# 如果explore失败，尝试基础探索
|
||||
print(f" ⚠️ AI探索失败: {str(e)[:50]}...")
|
||||
print(" 🔄 尝试基础探索...")
|
||||
try:
|
||||
# 基础探索：点击可见元素
|
||||
page = self.tester.browser.page
|
||||
clickable = page.locator("button, a, [role='button']")
|
||||
clicked = 0
|
||||
|
||||
for i in range(min(clickable.count(), 10)):
|
||||
try:
|
||||
elem = clickable.nth(i)
|
||||
if elem.is_visible():
|
||||
elem.click()
|
||||
self.tester.browser.wait(500)
|
||||
page.go_back()
|
||||
self.tester.browser.wait(500)
|
||||
clicked += 1
|
||||
except:
|
||||
continue
|
||||
|
||||
result["steps"].append({
|
||||
"action": "explore",
|
||||
"result": {
|
||||
"success": True,
|
||||
"click_count": clicked,
|
||||
"mode": "basic"
|
||||
}
|
||||
})
|
||||
print(f" ✅ 基础探索完成，点击了 {clicked} 个元素")
|
||||
except Exception as e2:
|
||||
result["steps"].append({
|
||||
"action": "explore",
|
||||
"result": {"success": False, "error": str(e2)}
|
||||
})
|
||||
elif action == "wait":
|
||||
duration = step.get("duration", 1000)
|
||||
self.tester.browser.wait(duration)
|
||||
result["steps"].append({
|
||||
"action": "wait",
|
||||
"duration": duration
|
||||
})
|
||||
elif action == "verify":
|
||||
# 执行验证
|
||||
target = step.get("target", "")
|
||||
verify_result = self.tester.verify(target)
|
||||
result["steps"].append({
|
||||
"action": "verify",
|
||||
"target": target,
|
||||
"result": verify_result
|
||||
})
|
||||
|
||||
def _run_verifications(self, result: Dict[str, Any]):
|
||||
"""运行验证规则"""
|
||||
page = self.tester.browser.page
|
||||
if not page:
|
||||
return
|
||||
|
||||
for verification in self.config.verifications:
|
||||
v_type = verification.get("type")
|
||||
value = verification.get("value")
|
||||
|
||||
try:
|
||||
if v_type == "url_contains":
|
||||
if value not in page.url:
|
||||
result["status"] = "failed"
|
||||
result["errors"].append(f"URL不包含{value}")
|
||||
|
||||
elif v_type == "element_exists":
|
||||
if page.locator(value).count() == 0:
|
||||
result["status"] = "failed"
|
||||
result["errors"].append(f"元素不存在: {value}")
|
||||
|
||||
elif v_type == "text_contains":
|
||||
if not page.locator(f"text={value}").count():
|
||||
result["status"] = "failed"
|
||||
result["errors"].append(f"页面不包含文本: {value}")
|
||||
|
||||
except Exception as e:
|
||||
result["errors"].append(f"验证失败: {e}")
|
||||
|
||||
|
||||
def load_config_from_file(file_path: str) -> TestConfig:
|
||||
"""从文件加载配置"""
|
||||
with open(file_path, 'r', encoding='utf-8') as f:
|
||||
if file_path.endswith('.yaml') or file_path.endswith('.yml'):
|
||||
data = yaml.safe_load(f)
|
||||
else:
|
||||
data = json.load(f)
|
||||
|
||||
# 提取顶层配置，确保所有字段都被正确映射
|
||||
config_dict = {
|
||||
"url": data.get("url"),
|
||||
"name": data.get("name", "Web Test"),
|
||||
"mode": data.get("mode", "explore"),
|
||||
"headless": data.get("headless", True),
|
||||
"model": data.get("model", "glm"),
|
||||
"login": data.get("login"),
|
||||
"explore_config": data.get("explore_config", {}),
|
||||
"steps": data.get("steps", []),
|
||||
"verifications": data.get("verifications", [])
|
||||
}
|
||||
|
||||
return TestConfig(**config_dict)
|
||||
|
||||
|
||||
def main():
|
||||
"""主函数"""
|
||||
import argparse
|
||||
|
||||
parser = argparse.ArgumentParser(description="通用 Web 测试工具")
|
||||
parser.add_argument("--config", "-c", help="配置文件路径 (JSON/YAML)")
|
||||
parser.add_argument("--url", "-u", help="要测试的URL")
|
||||
parser.add_argument("--mode", "-m", choices=["explore", "goal", "hybrid"],
|
||||
help="测试模式")
|
||||
parser.add_argument("--model", choices=["claude", "openai", "glm", "mimo"],
|
||||
help="AI模型")
|
||||
parser.add_argument("--headless", action="store_true", help="无头模式")
|
||||
parser.add_argument("--output", "-o", help="输出报告路径")
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
# 加载配置
|
||||
if args.config:
|
||||
config = load_config_from_file(args.config)
|
||||
# 如果命令行提供了参数，覆盖配置文件中的设置
|
||||
if args.url: config.url = args.url
|
||||
if args.mode: config.mode = args.mode
|
||||
if args.model: config.model = args.model
|
||||
if args.headless: config.headless = True
|
||||
else:
|
||||
# 使用命令行参数创建配置
|
||||
if not args.url:
|
||||
print("错误: 必须提供 --url 或 --config")
|
||||
sys.exit(1)
|
||||
config = TestConfig(
|
||||
url=args.url,
|
||||
mode=args.mode or "explore",
|
||||
model=args.model or "glm",
|
||||
headless=args.headless,
|
||||
name=f"Test_{args.url.replace('://', '_').replace('/', '_')}"
|
||||
)
|
||||
|
||||
# 运行测试
|
||||
tester = UniversalWebTester(config)
|
||||
result = tester.run()
|
||||
|
||||
# 输出结果
|
||||
print("\n" + "="*50)
|
||||
print(f"测试名称: {result['name']}")
|
||||
print(f"测试URL: {result['url']}")
|
||||
print(f"测试状态: {'✅ 通过' if result['status'] == 'passed' else '❌ 失败'}")
|
||||
|
||||
if result['errors']:
|
||||
print("\n错误信息:")
|
||||
for error in result['errors']:
|
||||
print(f" - {error}")
|
||||
|
||||
# 保存报告
|
||||
if args.output:
|
||||
with open(args.output, 'w', encoding='utf-8') as f:
|
||||
json.dump(result, f, ensure_ascii=False, indent=2)
|
||||
print(f"\n报告已保存到: {args.output}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Reference in New Issue
Block a user