Compare commits

..

No commits in common. "Agent-dev" and "main" have entirely different histories.

180 changed files with 14077 additions and 9034 deletions

View File

@ -1,13 +1,12 @@
# Coverage configuration # Coverage configuration
# Run: pytest --cov --cov-report=html --cov-report=term # Run: pytest --cov=tests --cov-report=html --cov-report=term
[run] [run]
source = backend, agent, framework, plugins source = tests
omit = omit =
*/__init__.py tests/__init__.py
tests/* tests/*/__init__.py
frontend/* tests/*/tests/__init__.py
work/*
[report] [report]
exclude_also = exclude_also =

1
.e2e_state.json Normal file
View File

@ -0,0 +1 @@
{}

View File

@ -1,37 +1,64 @@
# =========================================== # ===========================================
# LLM API 配置 # 测试环境配置示例
# =========================================== # ===========================================
DEEPSEEK_API_KEY=sk-your-api-key-here # 复制此文件为 .env 并填入实际值
OPENAI_API_KEY=sk-your-api-key-here # cp .env.example .env
OPENAI_BASE_URL=https://ai-api.d-robotics.cc/v1
# =========================================== # ===========================================
# 测试平台登录凭证 # 必需配置
# =========================================== # ===========================================
TEST_USERNAME=your_username
TEST_PASSWORD=your_password # 平台基础 URL
BASE_URL=https://cloud-fat.d-robotics.cc
# SSO 登录 URL
SSO_URL=https://sso-fat.d-robotics.cc
# 测试账号(必须配置)
TEST_USERNAME=your_test_username
TEST_PASSWORD=your_test_password
# =========================================== # ===========================================
# 后端安全配置(生产环境必须设置) # 浏览器配置(可选)
# =========================================== # ===========================================
# API 认证 Token(设置后所有 API 请求需携带 Authorization: Bearer <token>)
# 留空则关闭认证(仅开发模式推荐)
PLATFORM_API_TOKEN=
# Flask 运行环境(development / production) # 浏览器类型
FLASK_ENV=development BROWSER=chromium
# CORS 允许的来源(逗号分隔,生产环境必须设置) # 无头模式(CI 环境建议 true)
CORS_ORIGINS=http://localhost:5174,http://127.0.0.1:5174,http://localhost:5002 HEADLESS=true
# 慢动作延迟(调试时使用)
SLOW_MO=0
# 视口大小
VIEWPORT_WIDTH=1920
VIEWPORT_HEIGHT=1080
# =========================================== # ===========================================
# 任务执行配置 # 超时配置(可选)
# =========================================== # ===========================================
# 单个任务最大运行时间(秒,默认 3600)
TASK_TIMEOUT_SECONDS=3600 # 默认操作超时(毫秒)
DEFAULT_TIMEOUT=15000
# 导航超时(毫秒)
NAVIGATION_TIMEOUT=30000
# =========================================== # ===========================================
# SSH Key(从源码硬编码迁移至环境变量) # LLM 配置(可选 - AI辅助测试生成)
# =========================================== # ===========================================
SSH_PUBLIC_KEY=
DM_SSH_KEY= LLM_API_BASE=
LLM_API_KEY=
LLM_MODEL=ali/glm-5
LLM_TEMPERATURE=0.7
LLM_MAX_TOKENS=4096
# ===========================================
# 代理配置(可选)
# ===========================================
# HTTP_PROXY=http://proxy.example.com:8080
# HTTPS_PROXY=http://proxy.example.com:8080
# all_proxy=http://proxy.example.com:8080

82
.gitignore vendored
View File

@ -1,47 +1,57 @@
# 敏感文件
.env
platform_db.json
backend/db.json
.auth/
# 虚拟环境
.venv/
venv/
env/
# 运行时数据
work/
output/
platform_reports/
platform_artifacts/
reports/
*.log
# 本地截图 & 测试数据
local_*.png
tests/features/screenshots/
tests/data_generation/*.json
# Python # Python
__pycache__/ __pycache__/
*.pyc *.py[cod]
*.pyo
*.egg-info/ *.egg-info/
.pytest_cache/ dist/
.mypy_cache/ build/
.ruff_cache/ .venv/
.venv311/
venv/
# 前端 # Environment
frontend/node_modules/ .env
frontend/dist/ .env.local
frontend/pnpm-lock.yaml
frontend/tsconfig*.tsbuildinfo # Docs (local only)
docs/
# Auth
.auth/
# Outputs
reports/
screenshots/
logs/
*.log
# IDE # IDE
.idea/
.vscode/ .vscode/
.idea/
*.swp *.swp
*.swo *.swo
# macOS # OS
.DS_Store .DS_Store
Thumbs.db
# Frontend
frontend/node_modules/
frontend/dist/
# Platform
backend/db.json
platform_db.json
platform_reports/
platform_artifacts/
# Test artifacts
tests/features/screenshots/
tests/features/reports/
# OpenCode
.opencode/
.understand-anything/
# Node
node_modules/.e2e_state.json
.pytest_cache/

10
.pre-commit-config.yaml Normal file
View File

@ -0,0 +1,10 @@
# Pre-commit hooks — run `pip install pre-commit && pre-commit install`
# Generates: .git/hooks/pre-commit that runs on every `git commit`
repos:
- repo: https://github.com/charliermarsh/ruff-pre-commit
rev: v0.8.0
hooks:
- id: ruff
args: [--fix, --exit-non-zero-on-fix]
- id: ruff-format

222
AGENTS.md
View File

@ -1,222 +0,0 @@
# AGENTS.md
本项目为 TestAgent 配置与运行时文档,用于驱动 LLM 自动生成符合 TDD+DDD 规范的测试用例,并提供 Web 可视化管理平台。
## 运行环境
- **Web 平台**:Flask 后端(端口 5002)+ React SPA 前端(端口 5174 开发模式,生产构建后由 Flask 托管)
- **CLI 模式**:Python 3.9+,Click 命令行框架
- **语言模型**:DeepSeek Chat(默认)/ OpenAI / Anthropic(通过兼容 API 接入)
- **已有用例**:集成 unified-test-platform 的 `tests/` 目录,可浏览和运行 800+ 存量测试
## 启动方式
### Web 平台
```bash
# 启动后端(托管前端 SPA)
python -m backend
# 访问 http://localhost:5002
# 前端开发模式(热更新)
cd frontend && pnpm dev
# 访问 http://localhost:5174,API 代理到 5002
# 前端构建(生产)
cd frontend && pnpm build
# 产物输出到 frontend/dist/,由 Flask 直接托管
```
### CLI 命令行
```bash
# 完整扫描生成
python main.py run -r <git-url> -k <api-key>
# 精确回归
python main.py diff -r <git-url> -k <api-key> -a HEAD~3
# 领域分析(不调 LLM,免费)
python main.py analyze -r <git-url> -k <api-key>
```
## Web 平台功能
### 控制台 (`/dashboard`)
- 统计概览:仓库数、任务数、报告数、已有用例模块数
- 快速操作:跳转扫描仓库 / 运行已有用例 / 查看任务
- 能力展示:8 项平台能力卡片
### 仓库管理 (`/repos`)
- 添加 Git 仓库 → 自动扫描(clone/pull + AST 分析 + DDD 建模)
- 扫描完成后可执行:DDD 分析 / 生成测试 / 精确回归 / 全流程一键执行
- 实时 SSE 日志流显示扫描/分析/生成进度
- 展示限界上下文列表
### 任务管理 (`/tasks`)
- 任务列表:名称、类型、状态(运行中/通过/失败/等待中)、创建时间
- 实时 SSE 日志流(点击「日志」按钮)
- 运行中任务可停止,已完成任务可删除
- 5 秒轮询自动刷新状态
### 测试报告 (`/reports`)
- 报告列表:通过/失败标识、通过数/失败数、完成时间
- 详情面板:总运行/通过/失败/耗时统计
- 运行日志回放
- 失败截图查看
### 已有用例 (`/existing`)
- 左侧:22 个测试模块列表(来自 unified-test-platform)
- 中间:19 个测试标记(smoke/e2e/api/ui/flow/各模块标记)
- 右侧:运行配置(有头/无头模式)+ 运行按钮
- 选中模块后显示该模块的具体测试文件
- 实时 SSE 日志流显示 pytest 输出
## 知识来源
Agent 知识全部来自 `skills/` 目录下的 SKILL.md 文件:
- `skills/tdd-methodology/` — TDD 红-绿-重构循环、FIRST 原则、AAA 模式、测试替身
- `skills/ddd-patterns/` — 限界上下文、聚合根、实体、值对象、领域服务、仓储模式
- `skills/test-framework/` — 测试分层(冒烟/集成/系统/回归)、指标门禁、CI/CD 流水线
- `skills/language-patterns/` — Python/TypeScript/Go 多语言测试模式
如需更新知识:直接编辑对应的 SKILL.md 文件,无需重启。
## 工具
Agent 通过 `plugins/` 目录加载工具:
- `plugins/pylint_analyzer/` — 代码静态分析(行长度、TODO 标记、print 检测、复杂度评估)
- `plugins/test_runner/` — 测试运行器(执行 pytest、解析结果、指标门禁检查)
## 人格定义
Agent 人格定义在 `SOUL.md` 中,核心角色:
- **身份**:资深测试架构师,精通 TDD + DDD
- **输出**:可直接运行的 pytest 测试代码,无 TODO 或占位符
- **组织**:按 DDD 限界上下文组织测试目录,而非按文件结构
- **隔离**:领域层测试独立于基础设施层,领域层纯 Mock
- **命名**:`test_should_<预期行为>_when_<条件>` 模式
- **模式**:AAA(Arrange-Act-Assert)
## API Key 配置
```bash
# 方式1:Web 平台输入框(仓库管理/任务创建页面)
# 方式2:命令行传参
python main.py run -r <git-url> -k sk-xxx
# 方式3:环境变量
export DEEPSEEK_API_KEY=sk-xxx
python main.py run -r <git-url>
# 方式4:交互式输入
python main.py run -r <git-url>
# 请输入 API Key: ****
# 方式5:.env 文件
echo "DEEPSEEK_API_KEY=sk-xxx" > .env
python main.py run -r <git-url>
```
> **安全说明**:API Key 仅在内存中传递,不会持久化到 `platform_db.json`。任务创建后 API Key 字段从数据库记录中移除。
## 配置
在 `config.yaml` 中配置:
```yaml
agent:
model: deepseek-chat # 模型名称
provider: deepseek # deepseek / openai / anthropic
base_url: https://api.deepseek.com
temperature: 0.3 # 生成温度(0=确定,1=创意)
max_tokens: 8192
test_generation:
output_dir: tests # 测试输出目录
metrics_gate:
min_coverage: 60
min_pass_rate: 95
```
## 安全配置
### 环境变量
| 变量 | 说明 | 默认值 |
|------|------|--------|
| `PLATFORM_API_TOKEN` | API 认证 Token(留空则关闭认证) | - |
| `FLASK_ENV` | Flask 运行环境(development/production) | `development` |
| `CORS_ORIGINS` | CORS 允许来源(逗号分隔) | `http://localhost:5174,...` |
| `TASK_TIMEOUT_SECONDS` | 单任务最大运行时间(秒) | `3600` |
| `SSH_PUBLIC_KEY` | SSH 公钥(原硬编码迁移) | - |
| `DM_SSH_KEY` | 开发机 SSH Key(原硬编码迁移) | - |
### 生产部署
```bash
export PLATFORM_API_TOKEN="your-secret-token"
export FLASK_ENV=production
export CORS_ORIGINS="https://your-domain.com"
export TASK_TIMEOUT_SECONDS=3600
```
## API 路由
> **认证**:设置 `PLATFORM_API_TOKEN` 环境变量后,所有 API 请求(`/api/health` 豁免)需携带 `Authorization: Bearer <token>` 请求头。未设置时认证关闭。
>
> **速率限制**:关键 POST 端点按客户端 IP 限制(5-10 次/60 秒)。
>
> **SSRF 防护**:所有接受 Git URL 的端点仅允许 HTTPS 协议、拒绝内网 IP。
| 路由 | 方法 | 认证 | 速率限制 | 说明 |
|------|------|------|----------|------|
| `/api/health` | GET | 豁免 | - | 健康检查 |
| `/api/repos` | GET | ✅ | - | 仓库列表 |
| `/api/repos` | POST | ✅ | 10/60s | 扫描新仓库 |
| `/api/repos/branches` | GET | ✅ | - | 远程分支列表 |
| `/api/repos/compare` | POST | ✅ | 10/60s | 分支对比 |
| `/api/repos/check-ui` | POST | ✅ | 5/60s | UI 变更检查 |
| `/api/repos/fix-ui` | POST | ✅ | 5/60s | UI 自动修复 |
| `/api/repos/<id>/analyze` | POST | ✅ | - | DDD 领域分析 |
| `/api/repos/<id>/generate` | POST | ✅ | - | 生成测试用例 |
| `/api/repos/<id>/diff` | POST | ✅ | - | 精确回归 |
| `/api/repos/<id>/full` | POST | ✅ | 5/60s | 全流程(扫描+分析+生成) |
| `/api/tasks` | GET | ✅ | - | 任务列表 |
| `/api/tasks` | POST | ✅ | 10/60s | 创建任务 |
| `/api/tasks/<id>/stop` | POST | ✅ | - | 停止任务 |
| `/api/tasks/<id>/logs` | GET | ✅ | - | SSE 日志流 |
| `/api/reports` | GET | ✅ | - | 报告列表 |
| `/api/reports/<id>` | GET | ✅ | - | 报告详情 |
| `/api/existing-tests/modules` | GET | ✅ | - | 已有用例模块列表 |
| `/api/existing-tests/markers` | GET | ✅ | - | 已有用例标记列表 |
| `/api/dashboard/stats` | GET | ✅ | - | 控制台统计 |
## 生成规则
1. 严格遵循 SOUL.md 定义的测试架构师角色
2. 所有测试按 DDD 限界上下文组织,而非按源文件一对一映射
3. 领域层测试使用 Mock 隔离所有基础设施依赖
4. 基础设施层测试可以使用真实依赖
5. 每个测试函数必须有 docstring 描述测试意图
6. 使用 pytest 标记标注测试类型(smoke/integration/regression/e2e)
7. 自动注入指标门禁断言(覆盖率 >= 60%,通过率 >= 95%)
8. 不生成不安全的测试代码(eval、exec、硬编码密钥)
9. 只生成测试代码,不修改被测源代码
10. Session 领域测试独立成套件,覆盖创建/持久化/上下文携带/清除/销毁
## 数据持久化
- 数据库:`platform_db.json`(项目根目录)
- 任务日志:`platform_reports/<task_id>.json`
- 生成的测试:`output/<repo_id>/`
- 截图:`platform_artifacts/screenshots/`
- 前端构建产物:`frontend/dist/`
- 自动清理:任务超过 100 个时自动清除最旧 50 个及其关联资产
- **原子写入**:`platform_db.json` 使用 `tempfile + os.replace` 原子写入,防止崩溃时损坏
- **线程池**:`ThreadPoolExecutor(max_workers=4)` 限制并发任务
- **任务超时**:默认 3600 秒自动 kill 超时进程
- **日志轮转**:`RotatingFileHandler(maxBytes=10MB, backupCount=5)`

View File

@ -1,124 +0,0 @@
# Changelist - v1.1.0 (2026-07-15)
## 变更摘要
本次更新包含 **17 项修复**,涵盖安全性、稳定性、代码质量三个方面。
---
## 🔒 Security (5 项)
| # | 修复项 | 文件 | 说明 |
|---|--------|------|------|
| 1 | API Key 泄露 | `backend/app.py` | 从 `platform_db.json` 移除明文 API Key |
| 2 | CORS 全开放 | `backend/app.py` | 限制 CORS 允许来源 |
| 3 | 路径穿越漏洞 | `backend/app.py` | 添加路径校验防止 `../` 攻击 |
| 4 | Git 参数注入 | `backend/app.py` | 使用列表传参替代字符串拼接 |
| 5 | os.killpg 信号处理 | `backend/app.py` | 添加异常处理避免信号发送失败 |
## 🐛 Bug Fixes (7 项)
| # | 修复项 | 文件 | 说明 |
|---|--------|------|------|
| 6 | Flask debug 模式 | `backend/__main__.py` | 生产环境禁用 `debug=True` |
| 7 | SSE 连接泄漏 | `frontend/src/hooks/useTaskLogs.ts` | 组件卸载时自动关闭 EventSource |
| 8 | SSE 连接泄漏 | `frontend/src/components/repos/ReposView.tsx` | 内联 SSE 添加 ref 管理和 cleanup |
| 9 | fetch 静默吞错误 | `frontend/src/components/dashboard/Dashboard.tsx` | `.catch(() => {})` → `console.error` |
| 10 | fetch 静默吞错误 | `frontend/src/components/tasks/TasksView.tsx` | `.catch(() => {})` → `console.error` |
| 11 | fetch 静默吞错误 | `frontend/src/components/repos/ReposView.tsx` | `.catch(() => {})` → `console.error` |
| 12 | fetch 静默吞错误 | `frontend/src/components/reports/ReportsView.tsx` | `.catch(() => {})` → `console.error` |
| 13 | fetch 静默吞错误 | `frontend/src/components/existing/ExistingTestsView.tsx` | `.catch(() => {})` → `console.error` |
| 14 | `_run_ui_fix` 签名 | `backend/app.py` | 补全函数参数定义 |
| 15 | `.coveragerc` 配置 | `.coveragerc` | `source = tests` → `source = .` |
| 16 | `_load_db` 并发安全 | `backend/app.py` | 添加文件锁 + Queue maxsize + finally |
| 17 | SSE log_queues 泄漏 | `backend/app.py` | `WeakValueDictionary` 替代普通 dict |
## 🔧 Refactor (3 项)
| # | 修复项 | 文件 | 说明 |
|---|--------|------|------|
| 18 | BaseAPI → APIClient | `backend/app.py` | 统一 API 客户端命名 |
| 19 | 删除后端死代码 | `backend/app.py` | 移除重复 import、未使用变量 |
| 20 | 删除备份代码 | `framework/business_backup/` | 清理遗留备份目录 |
| 21 | 删除死代码 | `tests/conftest_metrics.py` | 清理未使用的测试配置 |
## 📝 Documentation (2 项)
| # | 修复项 | 文件 | 说明 |
|---|--------|------|------|
| 22 | 新增 CHANGELOG | `CHANGELOG.md` | 新增版本变更日志 |
| 23 | 更新 QUICKSTART | `docs/QUICKSTART.md` | 添加安全注意事项和常见问题 |
| 24 | 更新 CONFIG | `docs/CONFIG.md` | 添加安全加固和性能优化章节 |
---
## 文件变更统计
```
修改文件:
- backend/__main__.py
- backend/app.py
- .coveragerc
- .env.example
- docs/CONFIG.md
- docs/QUICKSTART.md
- frontend/src/components/dashboard/Dashboard.tsx
- frontend/src/components/existing/ExistingTestsView.tsx
- frontend/src/components/reports/ReportsView.tsx
- frontend/src/components/repos/ReposView.tsx
- frontend/src/components/tasks/TasksView.tsx
- frontend/src/hooks/useTaskLogs.ts
- frontend/vite.config.ts
- framework/business/billing.py
- framework/business/meal_reminder.py
- plugins/pylint_analyzer/__init__.py
- plugins/test_runner/__init__.py
新增文件:
- CHANGELOG.md
- CHANGELIST.md
删除文件:
- framework/business_backup/cloud_desktop_page.py
- framework/business_backup/dev_machine_page.py
- framework/business_backup/image_generation_page.py
- framework/business_backup/login.py
- framework/business_backup/login_page.py
- framework/business_backup/mirror_assets_page.py
- framework/business_backup/openclaw_page.py
- framework/business_backup/quantization_page.py
- framework/business_backup/three_d_assets_page.py
- framework/business_backup/three_d_generation_page.py
- tests/conftest_metrics.py
```
---
## 验证结果
- [x] 前端构建成功 (`pnpm build`)
- [x] 后端启动正常 (`python3 -m backend`)
- [x] 健康检查通过 (`/api/health` → 200)
- [x] 所有 `.catch(() => {})` 已替换
- [x] SSE 连接泄漏已修复
---
## 兼容性
- **向后兼容**:是
- **需要重启服务**:是
- **需要重新构建前端**:是(已构建)
---
## 后续建议
1. **定期审计**:每月检查 `platform_db.json` 是否包含敏感数据
2. **依赖更新**:定期更新 `requirements.txt` 和 `package.json`
3. **安全扫描**:集成 SAST 工具(如 Bandit)到 CI/CD
4. **日志监控**:配置日志告警,及时发现异常请求
---
Generated: 2026-07-15

View File

@ -1,88 +0,0 @@
# Changelog
所有对 TestAgent 智能测试平台的重要修改都将记录在此文件中。
格式基于 [Keep a Changelog](https://keepachangelog.com/zh-CN/1.0.0/),
版本号遵循 [Semantic Versioning](https://semver.org/lang/zh-CN/)。
## [Unreleased]
## [1.2.0] - 2026-07-15
### 🔒 Security
- **添加 API 认证中间件**:新增 `PLATFORM_API_TOKEN` 环境变量,设置后所有 API 请求需携带 `Authorization: Bearer <token>`,`/api/health` 豁免
- **SSRF 防护**:新增 `_validate_git_url()` 校验函数,仅允许 HTTPS 协议、拒绝内网 IP(10/172.16/192.168/169.254/127/::1/fc00::/fe80::),应用到所有接受 URL 的路由
- **路径遍历修复**:`module` 参数添加 `is_relative_to()` 校验,防止目录穿越
- **异常信息泄露修复**:添加 `@errorhandler(500)` 返回通用错误消息,`compare_branches` 异常不再返回 `str(e)`
- **API Key 不持久化**:所有路由改为 `task_with_key` 仅内存传递,`platform_db.json` 中不再存储 `api_key` 字段
- **硬编码 SSH Key 移除**:`SSH_PUBLIC_KEY` 和 `DevMachine.SSH_KEY` 从源码硬编码迁移至 `os.getenv()`
- **CORS 生产校验**:生产环境(`FLASK_ENV=production`)启动时检测 `CORS_ORIGINS` 未设置则 warning
### 🚦 Rate Limiting
- **新增内存滑动窗口速率限制**:`_rate_limit` 装饰器按客户端 IP 限制请求频率
- `POST /api/repos`:10 次/60 秒
- `POST /api/repos/compare`:10 次/60 秒
- `POST /api/repos/<id>/full`:5 次/60 秒
- `POST /api/repos/check-ui`:5 次/60 秒
- `POST /api/repos/fix-ui`:5 次/60 秒
- `POST /api/tasks`:10 次/60 秒
### ⚡ Performance & Stability
- **线程池限制**:裸 `threading.Thread` → `ThreadPoolExecutor(max_workers=4)`,防止无限创建线程
- **任务超时**:新增 `_enforce_proc_timeout()` Timer,两处 `subprocess.Popen` 后自动启动,超时 kill 进程组(默认 3600 秒,`TASK_TIMEOUT_SECONDS` 可配)
- **JSON 原子写入**:`_save_db` 改用 `tempfile.mkstemp` + `os.replace` 原子写入,防止进程崩溃时数据库损坏
- **日志轮转**:`logging.basicConfig` → `RotatingFileHandler(maxBytes=10MB, backupCount=5)`
- **httpx 连接池**:`LLMClient` 添加 `Limits(max_connections=10, max_keepalive_connections=5)`
### 🔧 Refactor
- **随机名改用 uuid4**:`FOLDER_NAME`/`DEV_MACHINE_NAME`/`CLOUD_DESKTOP_NAME`/`MIRROR_NAME` 从 `random.randint` 改为 `uuid.uuid4().hex[:8]`
- **前端 Error Boundary**:新增 `ErrorBoundary.tsx` 组件,在 `App.tsx` 中包裹全局
- **前端统一 EventSource**:`ReposView.tsx` 移除手动 `feEsRef`,统一使用 `useTaskLogs` hook
## [1.1.0] - 2026-07-15
### 🔒 Security
- **修复 API Key 泄露**:从 `platform_db.json` 中移除明文存储的 API Key,改为仅存储环境变量引用
- **修复 CORS 全开放**:限制 CORS 允许的来源,不再使用 ` origins='*' `
- **修复路径穿越漏洞**:添加路径校验,防止通过 `../` 等路径穿越读取任意文件
- **修复 Git 参数注入**:使用列表传参替代字符串拼接,防止命令注入攻击
- **修复 os.killpg 信号处理**:进程管理添加异常处理,避免信号发送失败导致崩溃
### 🐛 Bug Fixes
- **修复 Flask debug 模式**:生产环境禁用 `debug=True`,避免暴露 Werkzeug 调试器
- **修复 SSE 连接泄漏**:
- `useTaskLogs` hook 添加 cleanup 逻辑,组件卸载时自动关闭 EventSource
- `ReposView.tsx` 内联 SSE 连接添加 ref 管理和组件卸载清理
- **修复 fetch 静默吞错误**:所有前端 fetch 请求从 `.catch(() => {})` 改为输出有意义的错误日志
- **修复 `_run_ui_fix` 函数签名缺失**:补全函数参数定义
- **修复 `.coveragerc` 配置**:将 `source = tests` 改为 `source = .`,确保覆盖率统计正确
- **修复 `_load_db` 并发安全**:添加文件锁 + Queue maxsize + finally 清理
- **修复 SSE log_queues 内存泄漏**:使用 `weakref.WeakValueDictionary` 替代普通 dict
### 🔧 Refactor
- **BaseAPI → APIClient**:统一后端 API 客户端命名
- **删除后端死代码**:移除重复的 `import re`、未使用的变量和函数
- **删除 `business_backup` 目录**:清理遗留的备份代码
- **删除 `conftest_metrics.py`**:清理未使用的测试配置死代码
### 📝 Documentation
- 同步更新 `docs/CONFIG.md` 和 `docs/QUICKSTART.md`
## [1.0.0] - 2026-07-08
### ✨ Features
- TestAgent 智能测试平台初始版本
- Flask 后端 + React SPA 前端架构
- Git 仓库扫描、DDD 分析、测试生成
- 精确回归测试
- 已有用例集成(800+ 存量用例)
- SSE 实时日志流
- 测试报告 Dashboard
---
## 版本说明
- **主版本号 (Major)**:不兼容的 API 修改
- **次版本号 (Minor)**:向下兼容的功能新增
- **修订号 (Patch)**:向下兼容的问题修复

128
CONTRIBUTING.md Normal file
View File

@ -0,0 +1,128 @@
# 文档协作规则
本仓库是 AutoFlow 统一自动化测试平台(整合 D-Cloud + Robogo)的 Markdown 事实源。测试规范、测试用例、覆盖率报告、API 测试经验、Agent 任务和关键变更都应沉淀到仓库文档中,避免只停留在聊天记录、会议纪要或单个测试文件里。
## 1. 修改测试代码
如果新增、删除或调整 UI、API、Flow、E2E、异常、边界或综合测试,必须检查是否需要更新:
```text
test_cases/
docs/coverage/
history.md
```
测试代码应遵循:
```text
specs/AUTOMATION-SPEC.md
specs/TEST-WRITING-SPEC.md
```
## 2. 修改 Page Object
如果新增或重构页面对象、定位器、导航方法、业务动作、等待策略或 Mixin 能力,必须检查是否需要更新:
```text
specs/PAGE-OBJECT-SPEC.md
docs/PAGE_OBJECT_GUIDE.md
history.md
```
页面对象应优先封装业务动作,不应把复杂定位器和等待逻辑散落在测试用例中。
## 3. 修改 API 测试
如果 API 测试的路径、Header、入参、出参、业务状态码、关键字段、错误响应或边界规则发生变化,必须检查是否需要更新:
```text
specs/API-TEST-SPEC.md
api_docs/
swagger/
test_cases/
history.md
```
API 测试应至少覆盖 HTTP 状态码、业务状态码和关键字段;仅做连通性验证时,需要在测试或文档中说明原因。
## 4. 修改测试用例文档
如果需求、接口、页面流程、历史缺陷或自动化覆盖范围发生变化,必须检查是否需要更新:
```text
test_cases/
docs/coverage/
```
测试用例文档应遵循:
```text
specs/TEST-CASES-SPEC.md
```
## 5. 修改覆盖率报告
如果模块自动化覆盖率、未覆盖清单、MeterSphere 对照表或优先级建议发生变化,必须更新对应报告:
```text
docs/coverage/
```
覆盖率报告应区分:
- 已自动化覆盖。
- 部分覆盖。
- 未覆盖。
- 功能待确认。
## 6. 修改通用规范
如果测试目录、命名规则、pytest 标记、fixture 规则、Page Object 结构、API 断言策略、报告生成方式或文档结构发生变化,必须更新:
```text
specs/
README.md
history.md
```
规范变化可能影响多个模块,应在提交说明中写明影响范围。
## 7. 修改 Agent 任务
如果需要让 AI 或 Agent 执行一项可追踪任务,应在以下目录补充任务说明:
```text
agent_tasks/
```
Agent 任务应至少说明输入、输出、边界、验收标准、禁止事项和执行记录。
## 8. 修改文档结构
如果新增目录、调整文档地图、调整任务路由或关键词路由,必须更新:
```text
README.md
history.md
```
旧路径如果已被团队使用,应保留跳转说明或兼容索引。
## 9. 提交前检查
提交前至少检查:
- `README.md` 是否能路由到新增文档。
- 新增测试是否有对应 marker、模块目录和命名规则。
- API 测试是否覆盖业务状态码和关键字段。
- Page Object 是否封装了页面细节,测试用例是否保持业务可读。
- 测试用例、覆盖率和历史变更是否需要回写。
- 文档中是否出现真实账号、密码、token、cookie 或其他敏感信息。
## 10. 业务工程联动
业务代码工程和本自动化测试工程应保持关联:
- 业务需求或接口变更如果影响测试,应同步更新自动化测试和文档。
- 自动化测试发现的历史缺陷和回归风险,应回写到测试用例或覆盖率报告。
- AI 和 Agent 执行任务时,应优先读取本仓库文档,再修改测试代码。

31
Dockerfile Normal file
View File

@ -0,0 +1,31 @@
# syntax=docker/dockerfile:1
FROM python:3.12-slim-bookworm
RUN apt-get update && apt-get install -y --no-install-recommends \
libglib2.0-0 libnss3 libnspr4 libatk1.0-0 libatk-bridge2.0-0 \
libcups2 libdrm2 libdbus-1-3 libxkbcommon0 libxcomposite1 \
libxdamage1 libxfixes3 libxrandr2 libgbm1 libpango-1.0-0 \
libcairo2 libasound2 libatspi2.0-0 \
&& rm -rf /var/lib/apt/lists/*
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
RUN playwright install chromium && \
playwright install-deps chromium
COPY . .
RUN mkdir -p reports screenshots logs .auth
ENV HEADLESS=true
ENV DEFAULT_TIMEOUT=15000
ENV PYTEST_RUNNING=true
# Default: run all tests
CMD ["pytest", "-v"]
# To start the platform server instead:
# CMD ["python", "-m", "backend.app"]

334
README.md
View File

@ -1,160 +1,226 @@
# TestAgent — 智能测试平台 # AutoFlow — D-Robotics Unified Automation Testing Platform
基于 LLM 的自动化测试用例生成与管理平台,遵循 TDD(测试驱动开发)和 DDD(领域驱动设计)方法论。 AutoFlow 是 D-Robotics(地瓜机器人)的统一自动化测试平台,整合了两大测试能力:
提供 **CLI 命令行** 和 **Web 可视化平台** 两种交互方式,集成 unified-test-platform 已有 800+ 测试用例。 | 来源 | 产品 | 描述 |
|------|------|------|
| **data-loop-automation** | D-Cloud (视觉感知工作台) | 16 个业务模块的 E2E/API/UI/Flow 测试,819+ 个测试用例(含 40 条 E2E) |
| **test** | Robogo / 数据闭环 | 全链路 UI 巡检 + 飞书机器人 + 定时调度 |
## 技术栈
| 层级 | 技术 | 用途 |
|------|------|------|
| **后端** | Python 3.10+ + Flask | REST API、任务调度、SSE 实时日志 |
| **测试框架** | Pytest + Playwright | UI 自动化、API 测试、E2E 测试 |
| **前端** | React 19 + Vite + TailwindCSS 4 | 仪表盘、任务管理、报告中心、E2E 测试面板 |
| **消息** | Feishu Lark Bot | 飞书机器人命令触发 & 告警推送 |
| **容器** | Docker + Docker Compose | 一键部署 |
## 快速开始 ## 快速开始
### Web 平台(推荐) ### 环境要求
- Python >= 3.9(3.10+ 管道语法通过 `from __future__ import annotations` 兼容)
- Node.js >= 18 (用于前端)
- pnpm (推荐) 或 npm
### 安装
```bash ```bash
# 1. 安装依赖 # 1. 进入项目目录
cd unified-test-platform
# 2. 配置环境变量
cp .env.example .env
# 编辑 .env 填入实际值
# 3. 安装 Python 依赖
python3.11 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt pip install -r requirements.txt
# 2. 启动后端 # 4. 安装 Playwright 浏览器
python -m backend playwright install chromium
# 访问 http://localhost:5002
# 3. 前端开发(可选) # 5. 构建前端
cd frontend && pnpm install && pnpm dev cd frontend
# 访问 http://localhost:5174 pnpm install
pnpm build
cd ..
``` ```
### CLI 命令行 ### 启动
```bash ```bash
# 扫描仓库并生成测试 # 方式一:直接启动 Flask 后端(含前端)
python main.py run -r https://github.com/user/repo.git -k sk-your-api-key python -m backend.app
# 不传 API Key 会交互式提示输入 # 方式二:开发模式(前端热重载)
python main.py run -r https://github.com/user/repo.git # 终端 1: 启动后端
python -m backend.app
# 终端 2: 启动前端开发服务器
cd frontend && pnpm dev
# 访问 http://localhost:5173 (带 API 代理)
# 方式三:Docker
docker compose build
docker compose up -d
``` ```
## 页面功能 访问 `http://127.0.0.1:5001`
| 页面 | 路由 | 功能 | ### 运行测试
```bash
# 运行全部 D-Cloud 测试(856 个)
pytest tests/ -v
# 运行全部 E2E 测试(40 个)
pytest tests/ -m e2e -v
# 运行特定模块
pytest tests/data_generation/ -v
# 按 marker 运行
pytest -m smoke -v
pytest -m "api and data_space" -v
# 运行单个测试
pytest "tests/data_generation/tests/test_data_generation_full_pipeline.py::TestDataGenerationPipeline::test_full_pipeline_create_stop_delete" -v
# 运行 Robogo 巡检场景
python scenarios/run_all.py
# 启动飞书机器人
python bot/bot.py
# 生成覆盖率报告
pytest --cov=tests --cov=scenarios --cov-report=html
```
## 项目结构
```
unified-test-platform/
├── backend/ # Flask 后端 (API + 调度器 + SSE)
│ └── app.py # 主应用入口
├── frontend/ # React + Vite 前端
│ └── src/
│ ├── App.tsx
│ └── components/
│ ├── layout/ # PlatformSwitcher, Sidebar, navConfig
│ ├── dashboard/ # DCloudDashboard, RobogoDashboard
│ ├── tasks/ # 任务管理视图
│ ├── reports/ # 报告中心视图
│ └── test/ # TestModuleView, E2ETestView
├── tests/ # D-Cloud E2E 测试 (Pytest)
│ ├── base/ # POM 基类 + 10 个 Mixins
│ ├── utils/ # API 客户端、断言、Waiter
│ └── */ # 16 个业务测试模块
├── scenarios/ # Robogo 场景脚本
├── framework/ # 核心自动化框架
│ ├── core/ # BasePage, BaseUI, BaseAPI
│ ├── business/ # 页面对象 & 服务层
│ └── config/ # 场景级配置
├── bot/ # 飞书机器人
├── config/ # 统一配置管理
├── specs/ # 测试规格文档
├── swagger/ # API 文档
├── test_cases/ # 测试用例清单
├── docs/ # 文档中心
└── scripts/ # 工具脚本
```
## 前端架构:二合一平台切换
平台通过 **React Router** 实现单页应用内两个产品视图的切换:
| 路由 | 平台 | 功能 |
|------|------|------| |------|------|------|
| **控制台** | `/dashboard` | 统计概览(仓库/任务/报告/已有用例)+ 快速操作入口 | | `/dcloud` | D-Cloud (ToB) | 16 个模块卡片仪表盘,点击进入模块测试 |
| **仓库管理** | `/repos` | 添加 Git 仓库 → 扫描 → DDD 分析 → 生成测试 → 精确回归 → 全流程一键执行 | | `/dcloud/e2e` | E2E 全量测试 | API 全链路(8条) + UI 点击(3条) + 分步测试(3个) |
| **任务管理** | `/tasks` | 任务列表 + 实时 SSE 日志流 + 停止/删除 | | `/dcloud/:module` | 模块测试页 | 一键运行 pytest,SSE 实时日志流 |
| **测试报告** | `/reports` | 报告列表 + 详细日志 + 失败截图查看 | | `/robogo` | Robogo (ToC) | 全链路巡检仪表盘,趋势图、健康度分析 |
| **已有用例** | `/existing` | 浏览 unified-test-platform 的 22 个模块 800+ 用例,按模块/标记运行 | | `/robogo/tasks` | 任务管理 | 创建/调度/停止任务,SSE 实时日志 |
| `/robogo/reports` | 报告中心 | 历史报告列表 + 详情 + 截图 |
## CLI 命令 顶部 **PlatformSwitcher** 组件实现 D-Cloud / Robogo 一键切换,侧边栏根据当前平台显示不同导航。
| 命令 | 说明 | ### E2E 测试面板
`/dcloud/e2e` 页面包含三个测试区域:
**API 全链路(8条)** — 每条可单独运行,精确指定 pytest 测试路径:
- 任务全链路、任务结果、任务评测、LORA、系统提示词、工作流、数据空间、跨模块组合
**UI 点击测试(3条)** — 浏览器可见操作(`headless=false`),每条可单独运行:
- 任务创建、数据空间、跨模块导航
**分步测试(3个)** — 创建→去平台验证→清理,每步独立执行:
- 系统提示词、数据生成任务、数据空间
## D-Cloud 测试模块
| 模块 | Pytest Marker | 描述 |
|------|-------------|------|
| e2e | `e2e` | 跨模块端到端全链路测试(40 个用例) |
| workbench | `workbench` | 核心工作流 |
| data_generation | `data_generation` | 数据生成管线 |
| data_space | `data_space or dataspace` | 数据空间 |
| data_set | `dataset` | 数据集管理 |
| model_workshop | `model_workshop` | 模型训练与部署 |
| model_square | `model_square` | 模型广场 |
| monitor | `monitor` | 实时监控 |
| image_manage | `image_manage` | 图像管理 |
| mirror_center | `mirror_center` | 镜像中心 |
| cloud_desktop | `cloud_desktop` | 云端桌面 |
| dev_machine | `dev_machine` | 开发机 |
| device_manage | `device_manage` | 设备管理 |
| material_library | `material_library` | 素材库 |
| prompt_library | `prompt_library` | 提示词库 |
| lora_finetune | `lora_finetune` | LoRA 微调 |
## API 端点
| Method | Endpoint | 说明 |
|--------|----------|------|
| GET | `/api/health` | 健康检查 |
| GET | `/api/products` | 产品列表 |
| GET | `/api/dcloud-modules` | D-Cloud 模块列表(16 个) |
| GET/POST | `/api/tasks` | 任务列表 / 创建任务 |
| DELETE | `/api/tasks/<id>` | 删除任务 |
| POST | `/api/tasks/<id>/stop` | 停止任务 |
| GET | `/api/tasks/<id>/logs` | SSE 日志流 |
| GET | `/api/reports` | 报告列表 |
| GET | `/api/reports/<id>` | 报告详情 |
| GET | `/api/dashboard/stats` | 仪表盘统计 |
| GET | `/api/run-e2e-step` | E2E 分步测试(SSE 流) |
## 任务类型
| 类型 | 说明 | 执行方式 |
|------|------|---------|
| `scenario` | Robogo/数据闭环场景 | `python scenarios/run_all.py` |
| `dcloud_module` | 单个 D-Cloud 模块 | `pytest tests/<module>/ -v` |
| `dcloud_module` + `test` | 指定单个测试 | `pytest <test_path> -v` |
| `dcloud_e2e` | 全部 E2E 测试 | `pytest tests/ -m e2e -v` |
| `dcloud_all` | 全部 D-Cloud 测试 | `pytest tests/ -v` |
支持参数:`env`、`scope`、`headless`、`run_count`、`retry_on_fail`、`schedule_type`。
## 测试规模
| 维度 | 数量 |
|------|------| |------|------|
| `run` | 全量扫描生成 — 克隆仓库 → 分析代码 → 提取领域模型 → LLM 生成测试 | | 测试文件 | 68 个 |
| `diff` | 精确回归 — 只对 git diff 变更文件生成测试,自动映射限界上下文 | | 收集到的测试 | 856 个(含参数化) |
| `analyze` | 领域分析 — 只分析 DDD 领域模型,不调用 LLM(免费) | | E2E 测试 | 40 个(`-m e2e`) |
| 业务模块 | 16 个 |
## 测试类型 ## License
``` Internal use — D-Robotics
smoke 冒烟测试 — 核心主流程快速验证
unit 单元测试 — 领域层纯逻辑,Mock 隔离所有外部依赖
integration 集成测试 — 跨模块/跨服务接口联动
regression 回归测试 — 代码变更后精确回归
e2e 端到端测试 — 完整业务流程黑盒验证
```
## 5 步流水线 ---
``` **AutoFlow v2.0** — 从双平台到统一平台
┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
│ 1.拉取代码│ → │ 2.代码分析│ → │ 3.领域提取│ → │ 4.Prompt │ → │ 5.LLM生成 │
│ git clone │ │ AST解析 │ │ DDD建模 │ │ SOUL+技能 │ │ 测试用例 │
└──────────┘ └──────────┘ └──────────┘ └──────────┘ └──────────┘
```
## 生成的测试目录结构
```
tests/
├── domain/ # 领域层测试(纯逻辑,Mock 隔离)
│ └── {context_name}/
│ ├── test_entities.py
│ ├── test_value_objects.py
│ ├── test_services.py
│ └── test_aggregates.py
├── infrastructure/ # 基础设施层测试(真实依赖)
│ └── {context_name}/
│ ├── test_repositories.py
│ └── test_api.py
├── session/ # Session 领域测试
│ ├── test_session_lifecycle.py
│ └── test_session_context.py
├── smoke/ / integration/ / e2e/ # 分层测试
├── conftest.py # 全局 fixtures
└── domain_report.md # DDD 领域分析报告
```
## 配置
编辑 `config.yaml`:
```yaml
agent:
model: deepseek-chat # LLM 模型
provider: deepseek # deepseek / openai / anthropic
base_url: https://api.deepseek.com
temperature: 0.3
test_generation:
metrics_gate:
min_coverage: 60 # 覆盖率门禁
min_pass_rate: 95 # 通过率门禁
```
## 支持的编程语言
| 语言 | 分析能力 | 测试框架 |
|------|---------|---------|
| Python | AST 全量解析(类/函数/导入/装饰器) | pytest |
| TypeScript | 正则提取(类/函数/导入) | Jest |
| JavaScript | 正则提取 | Jest |
| Go | 基础行数统计 | testing |
| Java | 基础行数统计 | JUnit |
## 插件系统
| 插件 | 触发时机 | 功能 |
|------|---------|------|
| `pylint_analyzer` | pre_analysis | 代码静态质量扫描(行长度/TODO/print 检测) |
| `test_runner` | post_generation | 自动运行生成的测试 + 指标门禁检查 |
## 架构概览
```
┌──────────────────────────────────────┐
│ React SPA (Vite) │
│ Dashboard / Repos / Tasks / Reports │
│ /existing (已有用例) │
└────────────────┬─────────────────────┘
│ HTTP + SSE
┌────────────────▼─────────────────────┐
│ Flask Backend (端口 5002) │
│ API 路由 / 任务调度 / SSE 日志流 │
└────────────────┬─────────────────────┘
│
┌──────────────────────┼──────────────────────┐
│ │ │
┌─────────▼─────────┐ ┌────────▼────────┐ ┌─────────▼─────────┐
│ agent/ (引擎) │ │ unified-test- │ │ main.py (CLI) │
│ LLM + Git + AST │ │ platform/tests/ │ │ run/diff/analyze │
│ DDD + 测试生成 │ │ 800+ 已有用例 │ │ │
└───────────────────┘ └─────────────────┘ └───────────────────┘
```
## 与 hermes-bot 的对比
| 维度 | hermes-bot | TestAgent |
|------|-----------|-----------|
| 定位 | 飞书销售顾问机器人 | 智能测试用例生成与管理平台 |
| 交互方式 | 飞书 WebSocket 对话 | CLI + Web 可视化平台 |
| LLM 用途 | 自然语言对话 | 代码生成 |
| 知识库 | 产品/价格/销售流程 | TDD/DDD/测试框架规范 |
| 插件 | 报价计算/对话 guardrails | 静态分析/测试运行 |
| 输出 | 自然语言回复 | pytest 测试文件 + Web 任务管理 |
| 已有资产 | 无 | 集成 unified-test-platform 800+ 用例 |

48
SOUL.md
View File

@ -1,48 +0,0 @@
# TestAgent 角色定义
## 身份
你是一名资深测试架构师,精通 TDD(测试驱动开发)和 DDD(领域驱动设计)。
你的职责是扫描代码仓库,自动生成高质量、符合规范的测试用例。
你同时服务于 CLI 命令行和 Web 可视化平台两种交互场景。
## 核心原则
### TDD 红-绿-重构循环
1. **红阶段**:先写测试用例,测试必须失败
2. **绿阶段**:编写最小代码使测试通过
3. **重构阶段**:在测试保护下优化代码结构
### DDD 领域驱动设计
- **限界上下文**:按业务模块独立划分测试套件
- **聚合根/实体/领域服务**:最小业务粒度定义测试用例
- **统一语言**:测试用例、缺陷描述、需求文档使用一致术语
- **领域层隔离**:领域业务逻辑单元测试独立于基础设施层测试
### 测试分层
- **冒烟测试 (smoke)**:核心主流程快速验证,版本发布前必过
- **集成测试 (integration)**:跨模块/跨服务接口联动验证
- **系统测试 (system)**:完整产品黑盒全量验证
- **回归测试 (regression)**:代码变更后精确回归,按限界上下文自动筛选
- **指标测试 (metric)**:覆盖率≥60%、通过率≥95% 作为质量门禁
### Session 领域测试
- Session 是完整容器,包含 session_id、用户身份、模型参数配置、上下文窗口、对话历史、系统提示词
- 测试套件覆盖:Session 创建、历史持久化、上下文携带、历史清除、Session 销毁
### 平台能力
- 支持 CLI 命令行交互(`run`/`diff`/`analyze`)
- 支持 Web 平台可视化操作(仓库管理/任务管理/报告查看)
- 集成现有 unified-test-platform 的 800+ 测试用例,可直接运行
## 行为准则
1. 生成的测试代码必须可直接运行,不得有占位符或 TODO
2. 测试用例必须包含 AAA 模式(Arrange-Act-Assert)
3. 每个测试函数必须有清晰的 docstring 描述测试意图
4. 按 DDD 限界上下文组织测试目录结构,而非按文件结构
5. 领域层测试独立于基础设施层,不依赖数据库/网络/文件系统
6. 使用 pytest 标记标注测试类型(smoke/integration/regression/e2e)
7. 自动注入指标门禁断言
8. 不得生成不安全的测试代码(如 eval、exec、硬编码密钥)
9. 测试用例命名遵循 `should_<预期行为>_when_<条件>` 模式
10. 只生成测试代码,不修改被测源代码

View File

@ -1,196 +0,0 @@
import os
import logging
from pathlib import Path
from typing import Optional
import yaml
from agent.llm_client import LLMClient, LLMConfig
from agent.git_ops import GitOps, GitRepoInfo
from agent.code_analyzer import CodeAnalyzer, FileAnalysis
from agent.domain_extractor import DomainExtractor, DomainModel
from agent.prompt_builder import PromptBuilder
from agent.test_generator import TestGenerator
logger = logging.getLogger(__name__)
class TestAgent:
def __init__(self, config_path: str = "config.yaml"):
self.config = self._load_config(config_path)
self._setup_logging()
self.llm_config = LLMConfig(
provider=self.config.get("agent", {}).get("provider", "deepseek"),
model=self.config.get("agent", {}).get("model", "deepseek-chat"),
base_url=self.config.get("agent", {}).get("base_url", "https://api.deepseek.com"),
temperature=self.config.get("agent", {}).get("temperature", 0.3),
max_tokens=self.config.get("agent", {}).get("max_tokens", 8192),
)
self.work_dir = Path(self.config.get("git", {}).get("work_dir", "./work"))
self.output_dir = Path(self.config.get("test_generation", {}).get("output_dir", "tests"))
self.llm_client: Optional[LLMClient] = None
self.git_ops = GitOps(self.work_dir)
self.prompt_builder: Optional[PromptBuilder] = None
self._api_key: str = ""
def _load_config(self, config_path: str) -> dict:
path = Path(config_path)
if path.exists():
with open(path, "r", encoding="utf-8") as f:
return yaml.safe_load(f)
return {}
def _setup_logging(self):
level = getattr(logging, self.config.get("logging", {}).get("level", "INFO").upper(), logging.INFO)
fmt = self.config.get("logging", {}).get("format", "%(asctime)s [%(levelname)s] %(name)s: %(message)s")
logging.basicConfig(level=level, format=fmt)
def set_api_key(self, api_key: str):
self._api_key = api_key
self.llm_config.api_key = api_key
self.llm_client = LLMClient(self.llm_config)
base_dir = Path(__file__).parent.parent
skills_dir = base_dir / "skills"
soul_path = base_dir / "SOUL.md"
self.prompt_builder = PromptBuilder(skills_dir, soul_path)
def run(
self,
repo_url: str,
branch: str = "main",
test_types: list[str] = None,
output_dir: str = None,
) -> dict:
if not self._api_key:
raise ValueError("请先调用 set_api_key(api_key) 设置 API Key")
if test_types is None:
test_types = ["smoke", "unit", "integration"]
if output_dir:
self.output_dir = Path(output_dir)
logger.info(f"=== TestAgent 开始工作 ===")
logger.info(f"仓库: {repo_url}")
logger.info(f"分支: {branch}")
logger.info(f"测试类型: {test_types}")
logger.info(f"[1/5] 拉取代码...")
repo_info = self.git_ops.clone_or_pull(repo_url, branch)
logger.info(f" 语言: {repo_info.language}")
logger.info(f" 框架: {repo_info.framework}")
logger.info(f" 源文件: {len(repo_info.files)} 个")
logger.info(f"[2/5] 分析代码结构...")
analyzer = CodeAnalyzer(repo_info.local_path)
analyses = analyzer.analyze_all(repo_info.files)
logger.info(f" 分析完成: {len(analyses)} 个文件")
class_count = sum(len(a.classes) for a in analyses)
func_count = sum(len(a.functions) for a in analyses)
logger.info(f" 类: {class_count}, 函数: {func_count}")
logger.info(f"[3/5] 提取 DDD 领域模型...")
extractor = DomainExtractor(repo_info.local_path)
domain_model = extractor.extract_domains(analyses)
logger.info(f" 限界上下文: {len(domain_model.bounded_contexts)} 个")
for ctx in domain_model.bounded_contexts:
logger.info(f" - {ctx.name}: {len(ctx.files)} 个文件")
logger.info(f"[4/5] 读取源代码...")
source_codes = {}
for analysis in analyses:
source = self.git_ops.get_file_content(repo_info.local_path, analysis.path)
source_codes[analysis.path] = source
logger.info(f"[5/5] 调用 LLM 生成测试用例...")
generator = TestGenerator(self.llm_client, self.prompt_builder)
all_tests = generator.generate_tests_for_all(
analyses, source_codes, domain_model, test_types
)
test_output_dir = self.output_dir
written_files = generator.write_tests(all_tests, test_output_dir, domain_model)
logger.info(f" 生成测试文件: {len(written_files)} 个")
report = self._build_report(repo_info, analyses, domain_model, written_files, test_types)
return report
def run_diff(
self,
repo_url: str,
branch: str = "main",
against: str = "HEAD~1",
test_types: list[str] = None,
) -> dict:
if not self._api_key:
raise ValueError("请先调用 set_api_key(api_key) 设置 API Key")
if test_types is None:
test_types = ["regression", "unit"]
logger.info(f"=== TestAgent 精确回归模式 ===")
logger.info(f"仓库: {repo_url}")
logger.info(f"对比: {against}")
repo_info = self.git_ops.clone_or_pull(repo_url, branch)
diff_files = self.git_ops.get_diff(repo_info.local_path, against)
if not diff_files:
logger.info("没有检测到代码变更,跳过")
return {"changed_files": [], "generated_tests": []}
logger.info(f"变更文件: {len(diff_files)} 个")
for f in diff_files:
logger.info(f" - {f}")
analyzer = CodeAnalyzer(repo_info.local_path)
analyses = analyzer.analyze_all(diff_files)
extractor = DomainExtractor(repo_info.local_path)
domain_model = extractor.extract_domains(analyses)
source_codes = {}
for analysis in analyses:
source = self.git_ops.get_file_content(repo_info.local_path, analysis.path)
source_codes[analysis.path] = source
generator = TestGenerator(self.llm_client, self.prompt_builder)
all_tests = generator.generate_tests_for_all(
analyses, source_codes, domain_model, test_types
)
written_files = generator.write_tests(all_tests, self.output_dir, domain_model)
return {
"changed_files": diff_files,
"generated_tests": [str(f) for f in written_files],
"domain_contexts": [ctx.name for ctx in domain_model.bounded_contexts],
}
def _build_report(
self,
repo_info: GitRepoInfo,
analyses: list[FileAnalysis],
domain_model: DomainModel,
written_files: list[Path],
test_types: list[str],
) -> dict:
return {
"repo_url": repo_info.url,
"branch": repo_info.branch,
"language": repo_info.language,
"framework": repo_info.framework,
"files_analyzed": len(analyses),
"classes_found": sum(len(a.classes) for a in analyses),
"functions_found": sum(len(a.functions) for a in analyses),
"bounded_contexts": len(domain_model.bounded_contexts),
"context_names": [ctx.name for ctx in domain_model.bounded_contexts],
"test_types": test_types,
"test_files_generated": len(written_files),
"output_dir": str(self.output_dir),
"test_files": [str(f) for f in written_files],
}

View File

@ -1,306 +0,0 @@
import ast
import logging
from pathlib import Path
from dataclasses import dataclass, field
from typing import Optional
logger = logging.getLogger(__name__)
@dataclass
class ClassInfo:
name: str
file_path: str
line_start: int
line_end: int
methods: list["MethodInfo"] = field(default_factory=list)
base_classes: list[str] = field(default_factory=list)
decorators: list[str] = field(default_factory=list)
docstring: str = ""
is_abstract: bool = False
is_dataclass: bool = False
@dataclass
class MethodInfo:
name: str
file_path: str
class_name: str = ""
line_start: int = 0
line_end: int = 0
args: list[str] = field(default_factory=list)
return_type: str = ""
decorators: list[str] = field(default_factory=list)
docstring: str = ""
is_async: bool = False
is_static: bool = False
is_classmethod: bool = False
is_property: bool = False
@dataclass
class FunctionInfo:
name: str
file_path: str
line_start: int = 0
line_end: int = 0
args: list[str] = field(default_factory=list)
return_type: str = ""
decorators: list[str] = field(default_factory=list)
docstring: str = ""
is_async: bool = False
@dataclass
class ImportInfo:
module: str
names: list[str] = field(default_factory=list)
is_from_import: bool = False
alias: str = ""
@dataclass
class FileAnalysis:
path: str
language: str
classes: list[ClassInfo] = field(default_factory=list)
functions: list[FunctionInfo] = field(default_factory=list)
imports: list[ImportInfo] = field(default_factory=list)
docstring: str = ""
line_count: int = 0
class CodeAnalyzer:
def __init__(self, repo_path: Path):
self.repo_path = Path(repo_path)
def analyze_file(self, file_path: str) -> Optional[FileAnalysis]:
full_path = self.repo_path / file_path
if not full_path.exists():
logger.warning(f"文件不存在: {full_path}")
return None
ext = full_path.suffix
if ext == ".py":
return self._analyze_python(full_path, file_path)
elif ext in (".ts", ".tsx"):
return self._analyze_typescript(full_path, file_path)
else:
return self._analyze_generic(full_path, file_path)
def analyze_all(self, files: list[str]) -> list[FileAnalysis]:
results = []
for f in files:
analysis = self.analyze_file(f)
if analysis:
results.append(analysis)
return results
def _analyze_python(self, full_path: Path, rel_path: str) -> FileAnalysis:
analysis = FileAnalysis(path=rel_path, language="python")
try:
source = full_path.read_text(encoding="utf-8")
tree = ast.parse(source)
analysis.line_count = len(source.splitlines())
analysis.docstring = ast.get_docstring(tree) or ""
for node in ast.walk(tree):
if isinstance(node, ast.Import):
for alias in node.names:
analysis.imports.append(ImportInfo(
module=alias.name,
names=[alias.name],
alias=alias.asname or "",
))
elif isinstance(node, ast.ImportFrom):
analysis.imports.append(ImportInfo(
module=node.module or "",
names=[a.name for a in node.names],
is_from_import=True,
))
for node in ast.iter_child_nodes(tree):
if isinstance(node, ast.ClassDef):
class_info = self._extract_class_info(node, rel_path, source)
analysis.classes.append(class_info)
elif isinstance(node, ast.FunctionDef):
func_info = self._extract_function_info(node, rel_path, source)
analysis.functions.append(func_info)
elif isinstance(node, ast.AsyncFunctionDef):
func_info = self._extract_function_info(node, rel_path, source, is_async=True)
analysis.functions.append(func_info)
except SyntaxError as e:
logger.warning(f"Python 语法错误 {rel_path}: {e}")
except Exception as e:
logger.warning(f"分析文件失败 {rel_path}: {e}")
return analysis
def _extract_class_info(self, node: ast.ClassDef, rel_path: str, source: str) -> ClassInfo:
bases = []
for base in node.bases:
if isinstance(base, ast.Name):
bases.append(base.id)
elif isinstance(base, ast.Attribute):
bases.append(ast.unparse(base))
decorators = []
is_abstract = False
is_dataclass = False
for dec in node.decorator_list:
dname = ast.unparse(dec)
decorators.append(dname)
if "abstractmethod" in dname or "ABCMeta" in dname:
is_abstract = True
if "dataclass" in dname:
is_dataclass = True
class_info = ClassInfo(
name=node.name,
file_path=rel_path,
line_start=node.lineno,
line_end=node.end_lineno or node.lineno,
base_classes=bases,
decorators=decorators,
docstring=ast.get_docstring(node) or "",
is_abstract=is_abstract,
is_dataclass=is_dataclass,
)
for child in node.body:
if isinstance(child, ast.FunctionDef):
method = self._extract_function_info(child, rel_path, source)
method.class_name = node.name
class_info.methods.append(method)
elif isinstance(child, ast.AsyncFunctionDef):
method = self._extract_function_info(child, rel_path, source, is_async=True)
method.class_name = node.name
class_info.methods.append(method)
return class_info
def _extract_function_info(self, node, rel_path: str, source: str, is_async: bool = False) -> MethodInfo:
args = []
for arg in node.args.args:
arg_str = arg.arg
if arg.annotation:
arg_str += f": {ast.unparse(arg.annotation)}"
args.append(arg_str)
return_type = ""
if node.returns:
return_type = ast.unparse(node.returns)
decorators = []
is_static = False
is_classmethod = False
is_property = False
for dec in node.decorator_list:
dname = ast.unparse(dec)
decorators.append(dname)
if "staticmethod" in dname:
is_static = True
if "classmethod" in dname:
is_classmethod = True
if "property" in dname:
is_property = True
return MethodInfo(
name=node.name,
file_path=rel_path,
line_start=node.lineno,
line_end=node.end_lineno or node.lineno,
args=args,
return_type=return_type,
decorators=decorators,
docstring=ast.get_docstring(node) or "",
is_async=is_async,
is_static=is_static,
is_classmethod=is_classmethod,
is_property=is_property,
)
def _analyze_typescript(self, full_path: Path, rel_path: str) -> FileAnalysis:
analysis = FileAnalysis(path=rel_path, language="typescript")
try:
source = full_path.read_text(encoding="utf-8")
analysis.line_count = len(source.splitlines())
analysis.classes = self._extract_ts_classes(source, rel_path)
analysis.functions = self._extract_ts_functions(source, rel_path)
analysis.imports = self._extract_ts_imports(source)
except Exception as e:
logger.warning(f"分析 TypeScript 文件失败 {rel_path}: {e}")
return analysis
def _extract_ts_classes(self, source: str, rel_path: str) -> list[ClassInfo]:
import re
classes = []
pattern = re.compile(
r'(?:export\s+(?:abstract\s+)?)?class\s+(\w+)(?:\s+extends\s+(\w+))?\s*\{',
re.MULTILINE,
)
for match in pattern.finditer(source):
classes.append(ClassInfo(
name=match.group(1),
file_path=rel_path,
line_start=source[:match.start()].count("\n") + 1,
line_end=0,
base_classes=[match.group(2)] if match.group(2) else [],
))
return classes
def _extract_ts_functions(self, source: str, rel_path: str) -> list[FunctionInfo]:
import re
functions = []
pattern = re.compile(
r'(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)',
re.MULTILINE,
)
for match in pattern.finditer(source):
functions.append(FunctionInfo(
name=match.group(1),
file_path=rel_path,
line_start=source[:match.start()].count("\n") + 1,
args=[a.strip() for a in match.group(2).split(",") if a.strip()],
))
return functions
def _extract_ts_imports(self, source: str) -> list[ImportInfo]:
import re
imports = []
pattern = re.compile(
r'import\s+(?:{([^}]+)}|(\w+))\s+from\s+[\'"]([^\'"]+)[\'"]',
re.MULTILINE,
)
for match in pattern.finditer(source):
named = match.group(1)
default = match.group(2)
mod = match.group(3)
if named:
names = [n.strip().split(" as ")[0].strip() for n in named.split(",")]
else:
names = [default] if default else []
imports.append(ImportInfo(module=mod, names=names))
return imports
def _analyze_generic(self, full_path: Path, rel_path: str) -> FileAnalysis:
return FileAnalysis(
path=rel_path,
language=full_path.suffix.lstrip("."),
line_count=len(full_path.read_text(encoding="utf-8", errors="ignore").splitlines()),
)
def build_call_graph(self, analyses: list[FileAnalysis]) -> dict[str, list[str]]:
graph = {}
for analysis in analyses:
for func in analysis.functions:
key = f"{analysis.path}::{func.name}"
graph[key] = []
for imp in analysis.imports:
for name in imp.names:
if name in func.docstring:
graph[key].append(f"{imp.module}::{name}")
return graph

View File

@ -1,154 +0,0 @@
import logging
from pathlib import Path
from dataclasses import dataclass, field
from agent.code_analyzer import FileAnalysis, ClassInfo, FunctionInfo
logger = logging.getLogger(__name__)
@dataclass
class BoundedContext:
name: str
description: str
aggregate_roots: list[str] = field(default_factory=list)
entities: list[str] = field(default_factory=list)
value_objects: list[str] = field(default_factory=list)
domain_services: list[str] = field(default_factory=list)
repositories: list[str] = field(default_factory=list)
files: list[str] = field(default_factory=list)
@dataclass
class DomainModel:
bounded_contexts: list[BoundedContext] = field(default_factory=list)
shared_kernel: list[str] = field(default_factory=list)
ubiquitous_language: dict[str, str] = field(default_factory=dict)
class DomainExtractor:
def __init__(self, repo_path: Path):
self.repo_path = Path(repo_path)
def extract_domains(self, analyses: list[FileAnalysis]) -> DomainModel:
domain_model = DomainModel()
module_groups = self._group_by_module(analyses)
ubiquitous_language = self._extract_ubiquitous_language(analyses)
for module_name, files in module_groups.items():
context = self._analyze_module(module_name, files)
if context:
domain_model.bounded_contexts.append(context)
domain_model.shared_kernel = self._identify_shared_kernel(analyses)
domain_model.ubiquitous_language = ubiquitous_language
return domain_model
def _group_by_module(self, analyses: list[FileAnalysis]) -> dict[str, list[FileAnalysis]]:
groups = {}
for analysis in analyses:
parts = Path(analysis.path).parts
if len(parts) > 1:
top_level = parts[0]
else:
top_level = "root"
if top_level not in ("tests", "test", "__pycache__", ".git"):
if top_level not in groups:
groups[top_level] = []
groups[top_level].append(analysis)
return groups
def _analyze_module(self, module_name: str, analyses: list[FileAnalysis]) -> BoundedContext:
context = BoundedContext(name=module_name, description=f"{module_name} 限界上下文")
for analysis in analyses:
for cls in analysis.classes:
class_name = cls.name.lower()
file_path = cls.file_path
if cls.base_classes:
context.files.append(file_path)
if any(kw in class_name for kw in ("repository", "repo", "dao")):
context.repositories.append(cls.name)
elif any(kw in class_name for kw in ("service", "manager", "handler", "usecase")):
context.domain_services.append(cls.name)
elif any(kw in class_name for kw in ("model", "entity", "aggregate", "root")):
context.aggregate_roots.append(cls.name)
elif any(kw in class_name for kw in ("dto", "vo", "value", "event", "command", "query", "request", "response")):
context.value_objects.append(cls.name)
elif any(kw in class_name for kw in ("config", "util", "helper", "constant", "enum", "type")):
context.value_objects.append(cls.name)
else:
context.entities.append(cls.name)
for func in analysis.functions:
if func.name.startswith("_"):
continue
context.files.append(analysis.path)
context.files = list(set(context.files))
return context
def _extract_ubiquitous_language(self, analyses: list[FileAnalysis]) -> dict[str, str]:
language = {}
for analysis in analyses:
for cls in analysis.classes:
if cls.docstring:
first_line = cls.docstring.split("\n")[0].strip()
if first_line and len(first_line) < 200:
language[cls.name] = first_line
for func in analysis.functions:
if func.docstring:
first_line = func.docstring.split("\n")[0].strip()
if first_line and len(first_line) < 200:
language[func.name] = first_line
return language
def _identify_shared_kernel(self, analyses: list[FileAnalysis]) -> list[str]:
shared = []
for analysis in analyses:
for cls in analysis.classes:
if any(kw in cls.name.lower() for kw in (
"base", "abstract", "interface", "protocol", "mixin"
)):
if cls.base_classes:
shared.append(cls.name)
return shared
def map_file_to_context(self, file_path: str, contexts: list[BoundedContext]) -> str:
parts = Path(file_path).parts
if len(parts) > 1:
top_level = parts[0]
for ctx in contexts:
if ctx.name == top_level:
return ctx.name
return "shared_kernel"
def generate_context_report(self, domain_model: DomainModel) -> str:
lines = ["# DDD 领域分析报告", ""]
lines.append(f"## 限界上下文 ({len(domain_model.bounded_contexts)} 个)", "")
for ctx in domain_model.bounded_contexts:
lines.append(f"### {ctx.name}")
lines.append(f"- 描述: {ctx.description}")
lines.append(f"- 聚合根: {', '.join(ctx.aggregate_roots) if ctx.aggregate_roots else '无'}")
lines.append(f"- 实体: {', '.join(ctx.entities) if ctx.entities else '无'}")
lines.append(f"- 领域服务: {', '.join(ctx.domain_services) if ctx.domain_services else '无'}")
lines.append(f"- 仓储: {', '.join(ctx.repositories) if ctx.repositories else '无'}")
lines.append(f"- 值对象: {', '.join(ctx.value_objects) if ctx.value_objects else '无'}")
lines.append(f"- 涉及文件: {len(ctx.files)} 个")
lines.append("")
if domain_model.shared_kernel:
lines.append(f"## 共享内核: {', '.join(domain_model.shared_kernel)}", "")
if domain_model.ubiquitous_language:
lines.append("## 统一语言", "")
for term, definition in list(domain_model.ubiquitous_language.items())[:20]:
lines.append(f"- **{term}**: {definition}")
return "\n".join(lines)

View File

@ -1,139 +0,0 @@
import os
import logging
from pathlib import Path
from dataclasses import dataclass, field
from typing import Optional
logger = logging.getLogger(__name__)
@dataclass
class GitRepoInfo:
url: str
local_path: Path
branch: str = "main"
language: str = ""
framework: str = ""
files: list[str] = field(default_factory=list)
class GitOps:
def __init__(self, work_dir: Path):
self.work_dir = Path(work_dir)
self.work_dir.mkdir(parents=True, exist_ok=True)
def clone_or_pull(self, repo_url: str, branch: str = "main") -> GitRepoInfo:
repo_name = self._extract_repo_name(repo_url)
local_path = self.work_dir / repo_name
try:
import git
except ImportError:
raise ImportError("请安装 gitpython: pip install gitpython")
if local_path.exists():
logger.info(f"仓库已存在,执行 git pull: {local_path}")
repo = git.Repo(local_path)
origin = repo.remotes.origin
origin.fetch()
repo.git.checkout(branch)
origin.pull(branch)
else:
logger.info(f"克隆仓库: {repo_url} -> {local_path}")
git.Repo.clone_from(repo_url, local_path, branch=branch, depth=50)
info = self._analyze_repo(local_path)
info.url = repo_url
info.branch = branch
return info
def _extract_repo_name(self, repo_url: str) -> str:
name = repo_url.rstrip("/").split("/")[-1]
if name.endswith(".git"):
name = name[:-4]
return name
def _analyze_repo(self, local_path: Path) -> GitRepoInfo:
info = GitRepoInfo(url="", local_path=local_path, branch="main")
info.files = self._collect_source_files(local_path)
info.language = self._detect_language(info.files)
info.framework = self._detect_framework(local_path, info.language)
return info
def _collect_source_files(self, root: Path) -> list[str]:
ignore_dirs = {
"node_modules", "__pycache__", ".git", "dist", "build",
"vendor", ".venv", "venv", "env", ".tox", ".eggs", "*.egg-info",
".pytest_cache", ".mypy_cache", ".ruff_cache",
}
source_extensions = {
".py", ".ts", ".tsx", ".js", ".jsx", ".go", ".java",
}
files = []
for f in root.rglob("*"):
if f.is_file() and f.suffix in source_extensions:
parts = f.relative_to(root).parts
if not any(ig in parts for ig in ignore_dirs):
files.append(str(f.relative_to(root)))
return files
def _detect_language(self, files: list[str]) -> str:
ext_counts = {}
for f in files:
ext = Path(f).suffix
ext_counts[ext] = ext_counts.get(ext, 0) + 1
if not ext_counts:
return "unknown"
dominant = max(ext_counts, key=ext_counts.get)
lang_map = {
".py": "python",
".ts": "typescript",
".tsx": "typescript",
".js": "javascript",
".jsx": "javascript",
".go": "go",
".java": "java",
}
return lang_map.get(dominant, "unknown")
def _detect_framework(self, root: Path, language: str) -> str:
indicators = {
("requirements.txt", "fastapi"): "FastAPI",
("requirements.txt", "flask"): "Flask",
("requirements.txt", "django"): "Django",
("pyproject.toml", "pytest"): "Pytest",
("package.json", "vue"): "Vue",
("package.json", "react"): "React",
("package.json", "next"): "Next.js",
("go.mod", ""): "Go",
("pom.xml", ""): "Spring Boot",
}
for (filename, keyword), framework in indicators.items():
indicator_file = root / filename
if indicator_file.exists():
if keyword:
content = indicator_file.read_text(errors="ignore")
if keyword.lower() in content.lower():
return framework
else:
return framework
return "unknown"
def get_diff(self, repo_path: Path, against: str = "HEAD~1") -> list[str]:
try:
import git
except ImportError:
raise ImportError("请安装 gitpython: pip install gitpython")
repo = git.Repo(repo_path)
try:
diff = repo.git.diff("--name-only", against)
return [f for f in diff.split("\n") if f]
except git.GitCommandError:
return []
def get_file_content(self, repo_path: Path, file_path: str) -> str:
full_path = repo_path / file_path
if full_path.exists():
return full_path.read_text(encoding="utf-8", errors="ignore")
return ""

View File

@ -1,115 +0,0 @@
import os
import json
import httpx
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class LLMConfig:
provider: str = "deepseek"
model: str = "deepseek-chat"
base_url: str = "https://api.deepseek.com"
api_key: str = ""
temperature: float = 0.3
max_tokens: int = 8192
@dataclass
class LLMMessage:
role: str
content: str
@dataclass
class LLMResponse:
content: str
usage: dict = field(default_factory=dict)
class LLMClient:
def __init__(self, config: LLMConfig):
self.config = config
self._client = httpx.Client(
timeout=120.0,
limits=httpx.Limits(max_connections=10, max_keepalive_connections=5),
)
if config.provider == "deepseek":
self.config.base_url = self.config.base_url.rstrip("/")
def chat(self, messages: list[LLMMessage], system_prompt: str = "") -> LLMResponse:
full_messages = []
if system_prompt:
full_messages.append({"role": "system", "content": system_prompt})
for msg in messages:
full_messages.append({"role": msg.role, "content": msg.content})
headers = {
"Authorization": f"Bearer {self.config.api_key}",
"Content-Type": "application/json",
}
if self.config.provider == "deepseek":
url = f"{self.config.base_url}/v1/chat/completions"
else:
url = f"{self.config.base_url}/chat/completions"
payload = {
"model": self.config.model,
"messages": full_messages,
"temperature": self.config.temperature,
"max_tokens": self.config.max_tokens,
}
response = self._client.post(url, headers=headers, json=payload)
response.raise_for_status()
data = response.json()
content = data["choices"][0]["message"]["content"]
usage = data.get("usage", {})
return LLMResponse(content=content, usage=usage)
def chat_stream(self, messages: list[LLMMessage], system_prompt: str = ""):
full_messages = []
if system_prompt:
full_messages.append({"role": "system", "content": system_prompt})
for msg in messages:
full_messages.append({"role": msg.role, "content": msg.content})
headers = {
"Authorization": f"Bearer {self.config.api_key}",
"Content-Type": "application/json",
}
if self.config.provider == "deepseek":
url = f"{self.config.base_url}/v1/chat/completions"
else:
url = f"{self.config.base_url}/chat/completions"
payload = {
"model": self.config.model,
"messages": full_messages,
"temperature": self.config.temperature,
"max_tokens": self.config.max_tokens,
"stream": True,
}
with self._client.stream("POST", url, headers=headers, json=payload) as response:
response.raise_for_status()
for line in response.iter_lines():
if line.startswith("data: "):
data_str = line[6:]
if data_str == "[DONE]":
break
try:
data = json.loads(data_str)
delta = data["choices"][0].get("delta", {})
content = delta.get("content", "")
if content:
yield content
except json.JSONDecodeError:
continue
def close(self):
self._client.close()

View File

@ -1,188 +0,0 @@
import logging
from pathlib import Path
from typing import Optional
from agent.code_analyzer import FileAnalysis, ClassInfo, MethodInfo, FunctionInfo
from agent.domain_extractor import DomainModel, BoundedContext
logger = logging.getLogger(__name__)
class PromptBuilder:
def __init__(self, skills_dir: Path, soul_path: Path):
self.skills_dir = Path(skills_dir)
self.soul_path = Path(soul_path)
self._soul = self._load_soul()
self._skills_cache = {}
def _load_soul(self) -> str:
if self.soul_path.exists():
return self.soul_path.read_text(encoding="utf-8")
return ""
def _load_skill(self, skill_name: str) -> str:
if skill_name in self._skills_cache:
return self._skills_cache[skill_name]
skill_path = self.skills_dir / skill_name / "SKILL.md"
if skill_path.exists():
content = skill_path.read_text(encoding="utf-8")
self._skills_cache[skill_name] = content
return content
return ""
def build_system_prompt(self, domain_model: Optional[DomainModel] = None) -> str:
parts = [self._soul]
tdd_skill = self._load_skill("tdd-methodology")
if tdd_skill:
parts.append(f"\n## TDD 方法论\n{tdd_skill}")
ddd_skill = self._load_skill("ddd-patterns")
if ddd_skill:
parts.append(f"\n## DDD 模式\n{ddd_skill}")
test_fw_skill = self._load_skill("test-framework")
if test_fw_skill:
parts.append(f"\n## 测试框架规范\n{test_fw_skill}")
if domain_model and domain_model.bounded_contexts:
parts.append("\n## 当前项目的领域模型\n")
parts.append("请按以下限界上下文组织测试代码:\n")
for ctx in domain_model.bounded_contexts:
parts.append(f"### {ctx.name}")
parts.append(f"- 聚合根: {', '.join(ctx.aggregate_roots) if ctx.aggregate_roots else '无'}")
parts.append(f"- 实体: {', '.join(ctx.entities) if ctx.entities else '无'}")
parts.append(f"- 领域服务: {', '.join(ctx.domain_services) if ctx.domain_services else '无'}")
parts.append(f"- 仓储: {', '.join(ctx.repositories) if ctx.repositories else '无'}")
parts.append("")
if domain_model.ubiquitous_language:
parts.append("## 统一语言(术语表)\n")
for term, definition in list(domain_model.ubiquitous_language.items())[:30]:
parts.append(f"- **{term}**: {definition}")
return "\n\n".join(parts)
def build_file_context(self, analysis: FileAnalysis, source_code: str = "") -> str:
parts = [f"## 文件: {analysis.path}"]
parts.append(f"语言: {analysis.language}")
parts.append(f"行数: {analysis.line_count}")
if analysis.docstring:
parts.append(f"\n模块文档:\n{analysis.docstring}")
if analysis.imports:
parts.append(f"\n依赖导入:")
for imp in analysis.imports[:20]:
if imp.is_from_import:
parts.append(f" from {imp.module} import {', '.join(imp.names)}")
else:
parts.append(f" import {imp.module}")
if analysis.classes:
parts.append(f"\n类定义 ({len(analysis.classes)} 个):")
for cls in analysis.classes:
parts.append(self._format_class(cls))
if analysis.functions:
parts.append(f"\n函数定义 ({len(analysis.functions)} 个):")
for func in analysis.functions:
parts.append(self._format_function(func))
if source_code:
parts.append(f"\n源代码:\n```{analysis.language}\n{source_code}\n```")
return "\n".join(parts)
def _format_class(self, cls: ClassInfo) -> str:
parts = [f"\n 类: {cls.name}"]
if cls.base_classes:
parts.append(f" 继承: {', '.join(cls.base_classes)}")
if cls.decorators:
parts.append(f" 装饰器: {', '.join(cls.decorators)}")
if cls.docstring:
doc_short = cls.docstring.split("\n")[0][:100]
parts.append(f" 文档: {doc_short}")
if cls.is_abstract:
parts.append(" 抽象类: 是")
if cls.is_dataclass:
parts.append(" 数据类: 是")
if cls.methods:
parts.append(f" 方法 ({len(cls.methods)} 个):")
for m in cls.methods:
parts.append(f" - {m.name}({', '.join(m.args[:5])})")
if m.return_type:
parts[-1] += f" -> {m.return_type}"
if m.docstring:
doc_short = m.docstring.split("\n")[0][:80]
parts.append(f" {doc_short}")
return "\n".join(parts)
def _format_function(self, func: FunctionInfo) -> str:
parts = [f"\n 函数: {func.name}({', '.join(func.args[:5])})"]
if func.return_type:
parts[-1] += f" -> {func.return_type}"
if func.decorators:
parts.append(f" 装饰器: {', '.join(func.decorators)}")
if func.docstring:
doc_short = func.docstring.split("\n")[0][:100]
parts.append(f" 文档: {doc_short}")
if func.is_async:
parts.append(" 异步: 是")
return "\n".join(parts)
def build_test_generation_prompt(
self,
file_analysis: FileAnalysis,
source_code: str,
domain_model: DomainModel,
test_type: str = "unit",
) -> str:
file_context = self.build_file_context(file_analysis, source_code)
context_name = "shared_kernel"
for ctx in domain_model.bounded_contexts:
if file_analysis.path in ctx.files:
context_name = ctx.name
break
test_type_desc = {
"unit": "单元测试:测试单个函数/方法的逻辑,隔离所有外部依赖(数据库/网络/文件系统),使用 Mock/Stub",
"integration": "集成测试:测试跨模块/跨服务的接口联动,验证数据传递和参数透传",
"smoke": "冒烟测试:核心主流程快速验证,只覆盖最关键的 happy path",
"e2e": "端到端测试:完整业务流程黑盒验证,覆盖功能/边界/异常/兼容性",
"session": "Session 领域测试:测试 session 创建、历史持久化、上下文携带、历史清除、销毁",
}
prompt_parts = [
f"请为以下代码生成 {test_type_desc.get(test_type, test_type)}",
f"",
f"## 限界上下文: {context_name}",
f"",
file_context,
f"",
"## 生成要求",
"",
"1. 使用 pytest 框架",
"2. 测试函数命名遵循 `test_should_<预期行为>_when_<条件>` 模式",
"3. 每个测试函数必须有清晰的 docstring 描述测试意图",
"4. 遵循 AAA 模式(Arrange-Act-Assert)",
"5. 使用 `@pytest.mark.{test_type}` 标记测试类型",
"6. 对领域层测试,隔离所有基础设施依赖(使用 Mock)",
"7. 对基础设施层测试,可以使用真实依赖",
"8. 测试目录结构: tests/{domain_layer|infrastructure}/{context_name}/",
"9. 只生成测试代码,用 ```python 包裹,不要生成其他内容",
"10. 代码必须可直接运行,不得有 TODO 或占位符",
"",
"## 输出格式",
"",
"请按以下格式输出(每个测试文件一个代码块):",
"",
"```python",
"# tests/domain/{context_name}/test_{module_name}.py",
"实际测试代码...",
"```",
]
return "\n".join(prompt_parts)

View File

@ -1,197 +0,0 @@
import re
import logging
import json
from pathlib import Path
from typing import Optional
from agent.llm_client import LLMClient, LLMMessage
from agent.code_analyzer import FileAnalysis
from agent.domain_extractor import DomainModel
from agent.prompt_builder import PromptBuilder
logger = logging.getLogger(__name__)
class TestGenerator:
def __init__(self, llm_client: LLMClient, prompt_builder: PromptBuilder):
self.llm = llm_client
self.prompt_builder = prompt_builder
def generate_tests_for_file(
self,
file_analysis: FileAnalysis,
source_code: str,
domain_model: DomainModel,
test_type: str = "unit",
) -> dict[str, str]:
prompt = self.prompt_builder.build_test_generation_prompt(
file_analysis, source_code, domain_model, test_type
)
system_prompt = self.prompt_builder.build_system_prompt(domain_model)
messages = [LLMMessage(role="user", content=prompt)]
response = self.llm.chat(messages, system_prompt=system_prompt)
return self._parse_generated_tests(response.content)
def generate_tests_for_context(
self,
context_name: str,
analyses: list[FileAnalysis],
source_codes: dict[str, str],
domain_model: DomainModel,
test_types: list[str] = None,
) -> dict[str, dict[str, str]]:
if test_types is None:
test_types = ["smoke", "unit", "integration"]
all_results = {}
for analysis in analyses:
source = source_codes.get(analysis.path, "")
for test_type in test_types:
key = f"{analysis.path}::{test_type}"
results = self.generate_tests_for_file(
analysis, source, domain_model, test_type
)
all_results[key] = results
return all_results
def generate_tests_for_all(
self,
analyses: list[FileAnalysis],
source_codes: dict[str, str],
domain_model: DomainModel,
test_types: list[str] = None,
) -> dict[str, dict[str, str]]:
if test_types is None:
test_types = ["smoke", "unit", "integration"]
all_results = {}
for i, analysis in enumerate(analyses):
if analysis.line_count == 0:
continue
if any(pat in analysis.path for pat in ("__init__.py", "setup.py", "conftest.py")):
continue
source = source_codes.get(analysis.path, "")
logger.info(f"[{i+1}/{len(analyses)}] 生成测试: {analysis.path}")
for test_type in test_types:
key = f"{analysis.path}::{test_type}"
results = self.generate_tests_for_file(
analysis, source, domain_model, test_type
)
all_results[key] = results
return all_results
def _parse_generated_tests(self, content: str) -> dict[str, str]:
results = {}
pattern = re.compile(
r'```python\s*\n(?:#\s*(tests/[^\n]+)\s*\n)?(.*?)(?:```|$)',
re.DOTALL,
)
for match in pattern.finditer(content):
file_path = match.group(1)
code = match.group(2)
if file_path:
file_path = file_path.strip()
else:
file_path = "test_generated.py"
results[file_path] = code.strip()
if not results:
code_blocks = re.findall(r'```python\s*\n(.*?)(?:```|$)', content, re.DOTALL)
for i, code in enumerate(code_blocks):
if code.strip():
results[f"test_generated_{i+1}.py"] = code.strip()
return results
def write_tests(
self,
generated: dict[str, dict[str, str]],
output_dir: Path,
domain_model: DomainModel,
) -> list[Path]:
output_dir = Path(output_dir)
output_dir.mkdir(parents=True, exist_ok=True)
written_files = []
for key, test_files in generated.items():
for file_path, code in test_files.items():
if not code.strip():
continue
parts = file_path.split("/")
context_name = parts[1] if len(parts) > 2 else "shared_kernel"
full_path = output_dir / file_path
full_path.parent.mkdir(parents=True, exist_ok=True)
full_path.write_text(code, encoding="utf-8")
logger.info(f"写入测试文件: {full_path}")
written_files.append(full_path)
self._write_conftest(output_dir, domain_model)
written_files.append(output_dir / "conftest.py")
self._write_domain_report(output_dir, domain_model)
written_files.append(output_dir / "domain_report.md")
return written_files
def _write_conftest(self, output_dir: Path, domain_model: DomainModel):
markers = set()
for ctx in domain_model.bounded_contexts:
markers.add(ctx.name)
conftest = [
'"""DDD 测试框架 conftest - 按限界上下文组织"""',
"import pytest",
"",
]
for marker in sorted(markers):
conftest.append(f'pytest_plugins.append("{marker}")')
conftest.append("")
conftest.append("""
@pytest.fixture(scope="session")
def domain_model():
\"\"\"提供领域模型作为测试 fixture\"\"\"
return {}
@pytest.fixture
def mock_repository(mocker):
\"\"\"Mock 仓储层,隔离基础设施依赖\"\"\"
def _mock(repo_class):
return mocker.patch(f"{repo_class}.__init__", return_value=None)
return _mock
@pytest.fixture
def mock_external_service(mocker):
\"\"\"Mock 外部服务调用\"\"\"
def _mock(service_path, return_value=None):
return mocker.patch(service_path, return_value=return_value)
return _mock
def pytest_collection_modifyitems(config, items):
for item in items:
if "domain" in str(item.fspath):
item.add_marker(pytest.mark.domain)
elif "infrastructure" in str(item.fspath):
item.add_marker(pytest.mark.infrastructure)
""")
conftest_path = output_dir / "conftest.py"
conftest_path.write_text("\n".join(conftest), encoding="utf-8")
def _write_domain_report(self, output_dir: Path, domain_model: DomainModel):
from agent.domain_extractor import DomainExtractor
extractor = DomainExtractor(Path("."))
report = extractor.generate_context_report(domain_model)
report_path = output_dir / "domain_report.md"
report_path.write_text(report, encoding="utf-8")

View File

@ -1,264 +0,0 @@
import re
import logging
from pathlib import Path
from dataclasses import dataclass, field
from typing import Optional
logger = logging.getLogger(__name__)
@dataclass
class UISelector:
type: str # css, text, xpath, placeholder, role, attribute
value: str
file: str
line: int
context: str
@dataclass
class UIChange:
selector: UISelector
found_in_frontend: bool
frontend_file: str = ""
frontend_line: int = 0
suggestion: str = ""
class UIAnalyzer:
SELECTOR_PATTERNS = [
(re.compile(r"""page\.locator\(['"]([^'"]+)['"]"""), "css"),
(re.compile(r"""page\.get_by_text\(['"]([^'"]+)['"]"""), "text"),
(re.compile(r"""page\.get_by_placeholder\(['"]([^'"]+)['"]"""), "placeholder"),
(re.compile(r"""page\.get_by_role\(['"]([^'"]+)['"]"""), "role"),
(re.compile(r"""locator\(['"]([^'"]+)['"]"""), "css"),
(re.compile(r"""click\(['"]([^'"]+)['"]"""), "text"),
(re.compile(r"""fill\(['"]([^'"]+)['"]"""), "css"),
(re.compile(r"""input\[placeholder\*=['"]([^'"]+)['"]"""), "css"),
(re.compile(r"""button\[class\*=['"]([^'"]+)['"]"""), "css"),
(re.compile(r"""button\.(\w+)"""), "css_class"),
(re.compile(r"""#form_item_(\w+)"""), "css_id"),
(re.compile(r"""text=['"]([^'"]+)['"]"""), "text"),
(re.compile(r"""'([^']+)'\)"\)"""), "text"),
]
FRONTEND_SEARCH_PATTERNS = [
(re.compile(r'[\'"]([^\'"]*BTN[^\'"]*)[\'"]', re.IGNORECASE), "btn"),
(re.compile(r'[\'"]([^\'"]*button[^\'"]*)[\'"]', re.IGNORECASE), "button"),
(re.compile(r'[\'"]([^\'"]*login[^\'"]*)[\'"]', re.IGNORECASE), "login"),
(re.compile(r'[\'"]([^\'"]*input[^\'"]*)[\'"]', re.IGNORECASE), "input"),
(re.compile(r'className\s*[=:]\s*[\'"]([^\'"]+)[\'"]'), "class"),
(re.compile(r'id\s*[=:]\s*[\'"]([^\'"]+)[\'"]'), "id"),
(re.compile(r'placeholder\s*[=:]\s*[\'"]([^\'"]+)[\'"]'), "placeholder"),
(re.compile(r'>\s*([^<]{2,30})\s*<'), "text"),
(re.compile(r'aria-label\s*[=:]\s*[\'"]([^\'"]+)[\'"]'), "aria"),
]
def __init__(self, robogo_dir: Path):
self.robogo_dir = Path(robogo_dir)
def extract_selectors(self) -> list[UISelector]:
selectors = []
scripts_dir = self.robogo_dir / "framework" / "scripts"
business_dir = self.robogo_dir / "framework" / "business"
core_dir = self.robogo_dir / "framework" / "core"
for search_dir in [scripts_dir, business_dir, core_dir]:
if not search_dir.exists():
continue
for py_file in search_dir.rglob("*.py"):
if py_file.name.startswith("__"):
continue
try:
source = py_file.read_text(encoding="utf-8")
for pattern, sel_type in self.SELECTOR_PATTERNS:
for match in pattern.finditer(source):
value = match.group(1).strip()
if len(value) < 2 or value.startswith("http"):
continue
line = source[:match.start()].count("\n") + 1
context_start = max(0, match.start() - 30)
context_end = min(len(source), match.end() + 30)
context = source[context_start:context_end].replace("\n", " ").strip()
selectors.append(UISelector(
type=sel_type,
value=value,
file=str(py_file.relative_to(self.robogo_dir)),
line=line,
context=context,
))
except Exception as e:
logger.warning(f"分析文件失败 {py_file}: {e}")
return selectors
def check_frontend(self, selectors: list[UISelector], frontend_dir: Path) -> list[UIChange]:
changes = []
frontend_files = list(frontend_dir.rglob("*"))
frontend_texts = {}
for f in frontend_files:
if f.is_file() and f.suffix in (".tsx", ".ts", ".jsx", ".js", ".vue", ".html", ".css", ".scss", ".less"):
try:
content = f.read_text(encoding="utf-8", errors="ignore")
frontend_texts[str(f.relative_to(frontend_dir))] = content
except Exception:
pass
for sel in selectors:
found = False
found_file = ""
found_line = 0
for fpath, content in frontend_texts.items():
if sel.value in content:
found = True
found_file = fpath
idx = content.find(sel.value)
found_line = content[:idx].count("\n") + 1
break
if not found:
for pattern, ptype in self.FRONTEND_SEARCH_PATTERNS:
if sel.value in ["", " ", " "]:
continue
for fpath, content in frontend_texts.items():
for m in pattern.finditer(content):
if sel.value.lower() in m.group(1).lower() or m.group(1).lower() in sel.value.lower():
found = True
found_file = fpath
found_line = content[:m.start()].count("\n") + 1
break
if found:
break
if found:
break
suggestion = ""
if not found:
suggestion = f"前端代码中未找到选择器 '{sel.value}',UI 元素可能已变更或移除"
changes.append(UIChange(
selector=sel,
found_in_frontend=found,
frontend_file=found_file,
frontend_line=found_line,
suggestion=suggestion,
))
return changes
def generate_report(self, changes: list[UIChange]) -> str:
missing = [c for c in changes if not c.found_in_frontend]
found = [c for c in changes if c.found_in_frontend]
lines = ["# Robogo UI 元素变更分析报告", "", f"## 总览", ""]
lines.append(f"- 总选择器: {len(changes)}")
lines.append(f"- 匹配成功: {len(found)}")
lines.append(f"- 可能变更: {len(missing)}")
lines.append(f"- 匹配率: {len(found)/len(changes)*100:.1f}%" if changes else "- 匹配率: N/A")
lines.append("")
if missing:
lines.append(f"## 需要关注的变更 ({len(missing)} 个)")
lines.append("")
lines.append("| 文件 | 行号 | 选择器类型 | 选择器值 | 上下文 |")
lines.append("|------|------|-----------|---------|--------|")
for c in missing[:50]:
lines.append(f"| {c.selector.file} | {c.selector.line} | {c.selector.type} | `{c.selector.value[:60]}` | {c.selector.context[:50]} |")
lines.append("")
if found:
lines.append(f"## 已确认匹配 ({len(found)} 个)")
lines.append("")
lines.append("| 测试文件 | 前端文件 | 选择器 |")
lines.append("|---------|---------|--------|")
for c in found[:30]:
lines.append(f"| {c.selector.file} | {c.frontend_file} | `{c.selector.value[:50]}` |")
return "\n".join(lines)
def build_llm_prompt(self, changes: list[UIChange], frontend_dir: Path) -> str:
missing = [c for c in changes if not c.found_in_frontend]
if not missing:
return ""
prompt_parts = [
"以下 Robogo 测试脚本中的 UI 选择器在前端代码中未找到对应元素,请分析变更原因并给出修复建议:",
"",
]
for c in missing[:20]:
prompt_parts.append(f"### {c.selector.file}:{c.selector.line}")
prompt_parts.append(f"- 类型: {c.selector.type}")
prompt_parts.append(f"- 选择器: `{c.selector.value}`")
prompt_parts.append(f"- 上下文: `{c.selector.context}`")
prompt_parts.append("")
prompt_parts.append("请为每个失效的选择器提供:")
prompt_parts.append("1. 变更原因分析")
prompt_parts.append("2. 建议的修复代码(新的选择器)")
prompt_parts.append("3. 受影响的其他测试代码")
return "\n".join(prompt_parts)
def build_fix_prompt(self, changes: list[UIChange], frontend_dir: Path, batch_idx: int = 0, batch_size: int = 1) -> str:
"""构建自动修复 prompt"""
missing = [c for c in changes if not c.found_in_frontend]
if not missing:
return ""
by_file = {}
for c in missing:
f = c.selector.file
if f not in by_file: by_file[f] = []
by_file[f].append(c)
file_list = list(by_file.items())
batch = file_list[batch_idx * batch_size : (batch_idx + 1) * batch_size]
if not batch:
return ""
prompt_parts = [
"你是一个 Playwright 自动化测试专家。请修复以下测试文件中的失效 UI 选择器。",
"重要:保持原有代码结构和逻辑完全不变,只修改失效的 UI 选择器。",
"",
]
for f, items in batch:
prompt_parts.append("## {} ({} 个失效选择器)".format(f, len(items)))
for c in items[:5]:
prompt_parts.append("- L{}: `{}` ({})".format(c.selector.line, c.selector.value[:50], c.selector.type))
prompt_parts.append("")
full_path = Path(f)
if full_path.exists():
orig = full_path.read_text(encoding="utf-8")
prompt_parts.append("原始文件:")
prompt_parts.append("```python")
prompt_parts.append(orig)
prompt_parts.append("```")
prompt_parts.append("")
prompt_parts.append("请输出修复后的完整文件代码,格式:```python:{}\n代码\n```".format(batch[0][0] if batch else ""))
return "\n".join(prompt_parts)
def apply_fixes(self, changes: list[UIChange], llm_response: str, output_dir: Path) -> dict:
"""解析 LLM 修复代码并写入文件"""
import re
output_dir = Path(output_dir)
output_dir.mkdir(parents=True, exist_ok=True)
fixed_files = {}
pattern = re.compile(r'```python:([^\n]+)\n(.*?)```', re.DOTALL)
for match in pattern.finditer(llm_response):
filepath = match.group(1).strip()
code = match.group(2).strip()
if code:
out_path = output_dir / filepath
out_path.parent.mkdir(parents=True, exist_ok=True)
out_path.write_text(code, encoding='utf-8')
fixed_files[filepath] = len(code)
return fixed_files

49
agent_tasks/TEMPLATE.md Normal file
View File

@ -0,0 +1,49 @@
# Agent 任务模板
## 1. 任务信息
| 字段 | 内容 |
| --- | --- |
| 任务名称 | <任务名称> |
| 所属模块 | <模块名> |
| 创建时间 | YYYY-MM-DD |
| 维护方 | <团队或负责人> |
## 2. 任务目标
说明 Agent 需要完成什么,以及完成后的可验证结果。
## 3. 输入资料
| 资料 | 路径或说明 |
| --- | --- |
| 主索引 | `README.md` |
| 相关规范 | `specs/<SPEC>.md` |
| 相关用例 | `test_cases/<file>.md` |
| 相关代码 | `tests/<module>/` |
## 4. 输出要求
- 需要修改的文件:
- 需要新增的测试:
- 需要更新的文档:
- 需要运行的验证命令:
## 5. 边界和禁止事项
- 不得记录真实账号、密码、token、cookie。
- 不得破坏已有测试数据清理机制。
- 不得删除用户未确认的本地改动。
## 6. 验收标准
| 标准 | 验证方式 |
| --- | --- |
| 测试可收集 | `python -m pytest tests/<module>/ --collect-only -q` |
| 目标测试通过 | `python -m pytest tests/<module>/ -v` |
| 文档已回写 | 检查 `test_cases/`、`docs/coverage/`、`history.md` |
## 7. 执行记录
| 日期 | 执行人或 Agent | 结果 | 备注 |
| --- | --- | --- | --- |

22
api_docs/README.md Normal file
View File

@ -0,0 +1,22 @@
# API 测试对接文档目录
本目录用于沉淀从 `swagger/`、实际 API 请求日志和自动化测试中整理出的接口说明。
当前原始接口资料:
| 文件 | 说明 |
| --- | --- |
| `../swagger/dataspace_Api.json` | 数据空间相关接口原始资料 |
| `../swagger/imgGeneration.json` | 数据生成相关接口原始资料 |
API 测试规范见:
```text
../specs/API-TEST-SPEC.md
```
后续如果新增模块 API 文档,建议命名为:
```text
<模块名>_API测试对接文档.md
```

View File

@ -0,0 +1 @@
"""Unified Test Platform Backend"""

View File

@ -1,11 +1,8 @@
import os """Allow running backend as module: python -m backend"""
from backend.app import app from backend.app import app
from backend.scheduler import Scheduler
if __name__ == "__main__": if __name__ == "__main__":
app.run( print("Unified Test Platform starting... http://127.0.0.1:5001")
host=os.getenv("FLASK_HOST", "127.0.0.1"), Scheduler().start()
port=int(os.getenv("FLASK_PORT", "5002")), app.run(host="0.0.0.0", port=5001)
debug=os.getenv("FLASK_DEBUG", "0") == "1",
threaded=True,
)

File diff suppressed because it is too large Load Diff

40
backend/database.py Normal file
View File

@ -0,0 +1,40 @@
import os
import json
DB_FILE = os.path.join(os.path.dirname(__file__), "db.json")
tasks_db = {}
reports_db = {}
def load_db():
global tasks_db, reports_db
if os.path.exists(DB_FILE):
try:
with open(DB_FILE, "r", encoding="utf-8") as f:
data = json.load(f)
tasks_db = data.get("tasks", {})
reports_db = data.get("reports", {})
except Exception as e:
print(f"DB load failed: {e}")
def save_db():
try:
active_once = [
t for t in tasks_db.values()
if t.get("schedule_type", "once") == "once" and not t.get("is_deleted")
]
if len(active_once) > 100:
sorted_tasks = sorted(active_once, key=lambda t: t.get("created_at", ""))
for t in sorted_tasks[:50]:
tid = t.get("id")
if tid:
t["is_deleted"] = True
with open(DB_FILE, "w", encoding="utf-8") as f:
json.dump({"tasks": tasks_db, "reports": reports_db}, f, ensure_ascii=False)
except Exception:
pass
load_db()

68
backend/scheduler.py Normal file
View File

@ -0,0 +1,68 @@
import threading
import time
from datetime import datetime
from backend.database import tasks_db
from backend.test_runner import run_task_process
class Scheduler:
def _is_in_window(self, now, window_str):
if not window_str or window_str == "all":
return True
current_time = now.strftime("%H:%M")
try:
for part in window_str.split(","):
if "-" not in part:
continue
start, end = part.strip().split("-")
if start <= current_time <= end:
return True
except Exception:
pass
return False
def start(self):
threading.Thread(target=self._loop, daemon=True).start()
def _loop(self):
while True:
try:
now = datetime.now()
for tid, task in list(tasks_db.items()):
if task["status"] == "running":
continue
stype = task.get("schedule_type", "once")
last_run = task.get("last_scheduled_run")
should_run = False
if stype == "once" and task.get("scheduled_at") and task["status"] == "pending":
if now >= datetime.fromisoformat(task["scheduled_at"]):
should_run = True
elif stype == "continuous":
window = task.get("schedule_window", "00:00-23:59")
if self._is_in_window(now, window):
if last_run:
delta = (now - datetime.fromisoformat(last_run)).total_seconds()
if delta < 60:
continue
should_run = True
elif stype != "once":
if not last_run:
should_run = True
else:
delta = (now - datetime.fromisoformat(last_run)).total_seconds()
if (stype == "hourly" and delta >= 3600) or \
(stype == "daily" and delta >= 86400) or \
(stype == "weekly" and delta >= 86400 * 7):
should_run = True
if should_run:
task["last_scheduled_run"] = now.isoformat()
if stype == "once":
task["status"] = "running"
print(f"Triggered task: {task['name']} (type: {stype})")
threading.Thread(target=run_task_process, args=(task,), daemon=True).start()
except Exception as e:
print(f"Scheduler error: {e}")
time.sleep(30)

282
backend/test_runner.py Normal file
View File

@ -0,0 +1,282 @@
import os
import sys
import json
import queue
import signal
import threading
import subprocess
import time
import re
from datetime import datetime
import requests
from backend.database import tasks_db, reports_db, save_db
PROJECT_ROOT = os.path.dirname(os.path.dirname(__file__))
REPORTS_DIR = os.path.join(PROJECT_ROOT, "reports")
SCREENSHOTS_DIR = os.path.join(PROJECT_ROOT, "screenshots")
LARK_WEBHOOK = "https://open.feishu.cn/open-apis/bot/v2/hook/d75c14ad-d782-489e-8a99-81b511ee4abd"
log_queues = {}
process_pids = {}
os.makedirs(REPORTS_DIR, exist_ok=True)
os.makedirs(SCREENSHOTS_DIR, exist_ok=True)
def _resolve_python():
candidates = [
os.path.join(PROJECT_ROOT, ".venv311", "bin", "python3"),
os.path.join(PROJECT_ROOT, ".venv", "bin", "python3"),
os.path.join(PROJECT_ROOT, "venv", "bin", "python"),
]
for p in candidates:
if os.path.exists(p):
return p
return sys.executable
def send_alerts(report):
task_id = report.get("task_id")
task = tasks_db.get(task_id, {})
channels = task.get("alert_channels", [])
if "lark" in channels:
rule = task.get("alert_rule", "always")
if rule == "only_on_fail" and report["result"] == "PASS":
return
try:
status_color = "green" if report["result"] == "PASS" else "red"
status_text = "PASS" if report["result"] == "PASS" else "FAIL"
card = {
"config": {"wide_screen_mode": True},
"header": {
"title": {"tag": "plain_text", "content": f"Unified Test Report: {report['task_name']}"},
"template": status_color,
},
"elements": [
{
"tag": "div",
"fields": [
{"is_short": True, "text": {"tag": "lark_md", "content": f"**Status:** {status_text}"}},
{"is_short": True, "text": {"tag": "lark_md", "content": f"**Product:** {report['product']}"}},
{"is_short": True, "text": {"tag": "lark_md", "content": f"**Env:** {task.get('env', 'PROD')}"}},
{"is_short": True, "text": {"tag": "lark_md", "content": f"**Pass/Total:** {report['pass']}/{report['total_runs']}"}},
],
},
{"tag": "hr"},
{
"tag": "action",
"actions": [
{
"tag": "button",
"text": {"tag": "plain_text", "content": "View Report"},
"type": "primary",
"url": "http://127.0.0.1:5001/#/tasks",
}
],
},
],
}
requests.post(LARK_WEBHOOK, json={"msg_type": "interactive", "card": card}, timeout=5)
except Exception as e:
print(f"Feishu alert failed: {e}")
def run_task_process(task):
task_id = task["id"]
task["status"] = "running"
task["started_at"] = datetime.now().isoformat()
save_db()
q = log_queues.get(task_id)
logs_all = []
def push(msg, level="INFO"):
entry = {"ts": datetime.now().strftime("%H:%M:%S"), "level": level, "msg": msg}
logs_all.append(entry)
if q:
q.put(json.dumps(entry))
run_limit = int(task.get("run_count", 1))
retry_count = int(task.get("retry_count", 1)) if task.get("retry_on_fail") else 0
retry_delay = int(task.get("retry_delay", 5))
env = os.environ.copy()
env["ROBOGO_SCREENSHOTS_DIR"] = os.path.abspath(SCREENSHOTS_DIR)
env["ROBOGO_REPORTS_DIR"] = os.path.abspath(REPORTS_DIR)
env["ROBOGO_TASK_ID"] = task_id
env["ROBOGO_ENV"] = task.get("env", "PROD")
env["ROBOGO_SCOPE"] = task.get("scope", "all")
env["AUTH_ACCOUNT"] = task.get("account", "")
env["AUTH_PASSWORD"] = task.get("password", "")
env["ROBOGO_USER"] = task.get("account", "")
env["ROBOGO_PWD"] = task.get("password", "")
env["HEADLESS"] = task.get("headless", "true")
runner_type = task.get("runner", "script")
total_pass, total_fail = 0, 0
current_run = 0
planned_runs = run_limit
last_run_success = None
is_retry_run = False
push(f"Task started — Env: {env['ROBOGO_ENV']} | Scope: {env['ROBOGO_SCOPE']} | Runner: {runner_type}", "INFO")
python_bin = _resolve_python()
while current_run < run_limit:
current_run += 1
push(f"Run {current_run}/{planned_runs}...", "INFO")
try:
if runner_type == "pytest":
cmd = _build_pytest_cmd(task)
if cmd is None:
push(f"Unknown module: {task.get('module')}", "ERROR")
last_run_success = False
total_fail += 1
break
proc = subprocess.Popen(
cmd,
cwd=PROJECT_ROOT,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
text=True,
bufsize=1,
env=env,
preexec_fn=os.setsid if os.name != "nt" else None,
)
else:
if not task.get("entry"):
push("No entry script configured", "ERROR")
last_run_success = False
total_fail += 1
break
proc = subprocess.Popen(
[python_bin, task["entry"]],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
text=True,
bufsize=1,
env=env,
preexec_fn=os.setsid if os.name != "nt" else None,
)
process_pids[task_id] = proc.pid
for line in proc.stdout:
push(line.rstrip(), "INFO")
proc.wait()
process_pids.pop(task_id, None)
if proc.returncode == 0:
last_run_success = True
if is_retry_run:
total_fail = max(0, total_fail - 1)
total_pass += 1
push(f"Retry run {current_run} passed (overrides previous failure)", "SUCCESS")
else:
total_pass += 1
push(f"Run {current_run} passed", "SUCCESS")
is_retry_run = False
else:
last_run_success = False
total_fail += 1
push(f"Run {current_run} failed", "ERROR")
if retry_count > 0:
push(f"Retrying ({retry_count} left), waiting {retry_delay}s...", "WARN")
time.sleep(retry_delay)
retry_count -= 1
run_limit += 1
is_retry_run = True
else:
is_retry_run = False
except Exception as e:
push(f"System error: {e}", "ERROR")
last_run_success = False
total_fail += 1
is_retry_run = False
finished_at = datetime.now().isoformat()
final_result = "PASS" if last_run_success else "FAIL"
report = {
"task_id": task_id,
"task_name": task["name"],
"product": task["product"],
"total_runs": planned_runs,
"pass": total_pass,
"fail": total_fail,
"started_at": task["started_at"],
"finished_at": finished_at,
"result": final_result,
}
log_file = os.path.join(REPORTS_DIR, f"{task_id}.json")
try:
with open(log_file, "w", encoding="utf-8") as f:
json.dump({"logs": logs_all}, f, ensure_ascii=False)
except Exception:
pass
reports_db[task_id] = report
task["status"] = "pass" if final_result == "PASS" else "fail"
task["finished_at"] = finished_at
task["report_id"] = task_id
save_db()
send_alerts(report)
push("__DONE__", "DONE")
def _build_pytest_cmd(task):
module = task.get("module")
test_marker = task.get("test_marker", "")
test_file = task.get("test_file", "")
if test_file:
return [_resolve_python(), "-m", "pytest", test_file, "-v", "--tb=short", "--color=no"]
if test_marker:
return [_resolve_python(), "-m", "pytest", "tests/", "-m", test_marker, "-v", "--tb=short", "--color=no"]
if module:
test_dir = os.path.join(PROJECT_ROOT, "tests", module)
if not os.path.exists(test_dir):
return None
return [_resolve_python(), "-m", "pytest", str(test_dir), "-v", "--tb=short", "--color=no"]
return [_resolve_python(), "-m", "pytest", "tests/", "-v", "--tb=short", "--color=no"]
def stream_pytest(module, test=None):
"""Stream pytest output via SSE for the API server"""
cmd = _build_pytest_cmd({"module": module, "test_file": test})
if cmd is None:
return None
return cmd
def stop_task(tid):
pid = process_pids.get(tid)
task = tasks_db.get(tid)
if task:
if task.get("schedule_type") == "continuous":
task["schedule_type"] = "once"
task["status"] = "fail"
task["finished_at"] = datetime.now().isoformat()
if pid:
try:
os.killpg(os.getpgid(pid), signal.SIGKILL)
except Exception:
try:
os.kill(pid, signal.SIGKILL)
except Exception:
pass
process_pids.pop(tid, None)
save_db()

156
bot/bot.py Normal file
View File

@ -0,0 +1,156 @@
import re
import json
import threading
import concurrent.futures
from datetime import datetime
import lark_oapi as lark
from lark_oapi.api.im.v1 import (
CreateMessageRequest,
CreateMessageRequestBody,
)
from lark_oapi.event.callback.model.p2_card_action_trigger import P2CardActionTrigger
from framework.config.settings import Config as config
from framework.core.logger import get_logger
from framework.business.cloud_desktop import CloudDesktopService
from framework.business.dev_machine import DevMachineService
from framework.business.billing import BillingService
from framework.business.meal_reminder import MealReminderService
from framework.business.boilerplate import BoilerplateService
from framework.core.exceptions import TokenExpiredError
logger = get_logger("FeishuBot")
# ---------- 飞书卡片常量 ----------
TOKEN_UPDATE_CARD_ID = "AAq2uZZvyWY01"
RESULT_CARD_ID = "AAqKcs3OrZBnJ"
INTRO_CARD_ID = "AAq2uZZvyWY06"
# 线程池
executor = concurrent.futures.ThreadPoolExecutor(max_workers=10)
# ---------- 业务服务实例化 ----------
cd_service = CloudDesktopService()
dm_service = DevMachineService()
billing_service = BillingService()
meal_service = MealReminderService()
bp_service = BoilerplateService()
# ---------- 全局计数器 ----------
_counter_lock = threading.Lock()
_global_counter = 0
def _next_default_name() -> str:
global _global_counter
with _counter_lock:
_global_counter += 1
return f"验证{_global_counter:02d}"
# ---------- 飞书 API Client ----------
_lark_client = lark.Client.builder() \
.app_id(config.FEISHU_APP_ID) \
.app_secret(config.FEISHU_APP_SECRET) \
.build()
def send_feishu_message(chat_id: str, text: str):
body = CreateMessageRequestBody.builder().receive_id(chat_id).msg_type("text").content(json.dumps({"text": text})).build()
request = CreateMessageRequest.builder().receive_id_type("chat_id").request_body(body).build()
_lark_client.im.v1.message.create(request)
def send_card_json(chat_id: str, card_json: dict):
body = CreateMessageRequestBody.builder().receive_id(chat_id).msg_type("interactive").content(json.dumps(card_json)).build()
request = CreateMessageRequest.builder().receive_id_type("chat_id").request_body(body).build()
_lark_client.im.v1.message.create(request)
def _handle_single_task(chat_id, name, task_type):
try:
if task_type == "cd_post":
results, instance_id = cd_service.run_lifecycle_test(name, flow_type="postpaid_to_prepaid")
label = "云桌面(按转包)"
elif task_type == "cd_pre":
results, instance_id = cd_service.run_lifecycle_test(name, flow_type="prepaid_to_postpaid")
label = "云桌面(包转按)"
elif task_type == "bp":
results, instance_id = bp_service.run_lifecycle_test(name)
label = "样本工程"
else:
results, instance_id = dm_service.run_lifecycle_test(name)
label = "开发机"
send_feishu_message(chat_id, f"✅ {label} [{name}] 验证完成!")
except TokenExpiredError:
send_feishu_message(chat_id, "⚠️ 认证过期,请更新 Token")
except Exception as e:
logger.error(f"Task error: {e}")
send_feishu_message(chat_id, f"❌ {label} 验证异常: {e}")
def _parse_command(text: str):
patterns = {
"cd_post": r"robogo-云桌面[ \-:=]+(.+)$",
"cd_pre": r"robogo-云桌面包月[ \-:=]+(.+)$",
"dm": r"robogo-开发机[ \-:=]+(.+)$",
"bp": r"robogo-样本工程[ \-:=]+(.+)$",
"billing": r"账单[ \-:=]*(.*)$",
}
# 辅助匹配模式(不带名称的情况)
fallback_patterns = {
"cd_post": r"robogo-云桌面\s*$",
"cd_pre": r"robogo-云桌面包月\s*$",
"dm": r"robogo-开发机\s*$",
"bp": r"robogo-样本工程\s*$",
}
text_clean = text.strip()
logger.info(f"Parsing command from text: '{text_clean}'")
# 先试带有名称的模式
for cmd, p in patterns.items():
m = re.search(p, text_clean)
if m:
logger.info(f"Matched named pattern: {cmd}, name: {m.group(1).strip()}")
return cmd, m.group(1).strip()
# 再试默认模式
for cmd, p in fallback_patterns.items():
m = re.search(p, text_clean)
if m:
logger.info(f"Matched fallback pattern: {cmd}")
return cmd, None
logger.warning(f"No pattern matched for text: '{text_clean}'")
return None, None
def _on_message(data):
msg = data.event.message
chat_id = msg.chat_id
content = json.loads(msg.content)
text = content.get("text", "")
clean_text = re.sub(r'@[^ ]+', '', text).strip()
if "饭否" in clean_text:
send_card_json(chat_id, meal_service.build_card())
return
cmd, name = _parse_command(clean_text)
if cmd == "billing":
items = billing_service.fetch_billing_data(name)
send_feishu_message(chat_id, f"共找到 {len(items)} 条账单记录")
elif cmd:
name = name or _next_default_name()
executor.submit(_handle_single_task, chat_id, name, cmd)
else:
send_feishu_message(chat_id, "未能识别指令,请尝试 [robogo-云桌面] 或 [账单]")
def main():
# 使用 WebSocket (Long Polling) 模式,无需公网 IP
event_handler = lark.EventDispatcherHandler.builder(config.FEISHU_APP_ID, config.FEISHU_APP_SECRET) \
.register_p2_im_message_receive_v1(_on_message) \
.build()
ws_client = lark.ws.Client(config.FEISHU_APP_ID, config.FEISHU_APP_SECRET, event_handler=event_handler)
logger.info("Bot started in WebSocket mode...")
ws_client.start()
if __name__ == "__main__":
main()

View File

@ -0,0 +1,95 @@
import random
from datetime import datetime
from framework.core.base_api import BaseAPI
from framework.config.settings import Config
from framework.core.logger import get_logger
logger = get_logger("MealReminderService")
class MealReminderService(BaseAPI):
MEAL_PERIODS = {
"breakfast": {
"range": (6, 9), "emoji": "🌅", "label": "早餐", "keywords": "早餐|早点|咖啡",
"greetings": ["早安!中关村的早晨从热腾腾的早点开始 ☀️", "美好的早晨,看看附近有什么好吃的早餐 ☕"]
},
"lunch": {
"range": (10, 13), "emoji": "☀️", "label": "午餐", "keywords": "餐厅|快餐|中餐",
"greetings": ["午饭时间到!放下代码,看看公司附近吃什么 🍚", "到点干饭了,为您搜罗了附近的优质午餐 🤔"]
},
"afternoon_tea": {
"range": (14, 16), "emoji": "🍰", "label": "下午茶", "keywords": "甜品|饮品|咖啡",
"greetings": ["下午茶时间~来点甜的补充能量 🧁", "三点几嚟,饮茶先啦!🫖"]
},
"dinner": {
"range": (17, 20), "emoji": "🌆", "label": "晚餐", "keywords": "特色菜|火锅|烧烤|餐厅",
"greetings": ["下班啦!中关村的夜晚,吃顿好的犒劳自己 🎉", "晚餐时间到,看看壹号周边有哪些人气餐厅 🍽️"]
},
"late_night": {
"range": (21, 5), "emoji": "🌙", "label": "夜宵", "keywords": "烧烤|宵夜|快餐",
"greetings": ["深夜食堂正式营业!🏮", "加班辛苦了,看看附近有什么深夜美食 🌙"]
},
}
def __init__(self):
super().__init__("https://restapi.amap.com") # 高德 API 基地址
def get_current_period(self) -> dict:
hour = datetime.now().hour
for period_info in self.MEAL_PERIODS.values():
start, end = period_info["range"]
if start <= end:
if start <= hour <= end: return period_info
else:
if hour >= start or hour <= end: return period_info
return self.MEAL_PERIODS["lunch"]
def fetch_nearby_restaurants(self, keywords: str) -> list:
endpoint = "/v3/place/around"
params = {
"key": Config.AMAP_KEY,
"location": Config.AMAP_COORDINATES,
"keywords": keywords,
"types": "050000", # 餐饮服务
"radius": 1000,
"sortrule": "weight",
"offset": 10,
"page": 1,
"extensions": "all"
}
try:
# BaseAPI.request 默认会拼 BASE_URL,这里高德是不同的地址,手动处理或实例化时指定
import requests # 临时直接用 requests,或者修改 BaseAPI 支持绝对路径
resp = requests.get(f"{self.base_url}{endpoint}", params=params, timeout=5)
data = resp.json()
if data.get("status") == "1":
return data.get("pois", [])
except Exception as e:
logger.error(f"高德 API 调用失败: {e}")
return []
def build_card(self) -> dict:
period = self.get_current_period()
greeting = random.choice(period["greetings"])
pois = self.fetch_nearby_restaurants(period["keywords"])
elements = [{"tag": "div", "text": {"tag": "lark_md", "content": f"**{greeting}**"}}, {"tag": "hr"}]
if pois:
for poi in pois[:5]:
name = poi.get("name", "未知餐厅")
biz_ext = poi.get("biz_ext", {})
rating = biz_ext.get("rating") if isinstance(biz_ext, dict) else "暂无"
distance = poi.get("distance", "未知")
elements.append({
"tag": "div",
"text": {"tag": "lark_md", "content": f"🏠 **{name}**\n⭐️ 评分: {rating} | 📍 距离: {distance}m"}
})
else:
elements.append({"tag": "div", "text": {"tag": "lark_md", "content": "⚠️ 暂时没搜到附近的店"}})
elements.extend([{"tag": "hr"}, {"tag": "note", "elements": [{"tag": "plain_text", "content": f"🕒 {datetime.now().strftime('%H:%M')}"}]}])
return {
"header": {"title": {"tag": "plain_text", "content": f"{period['emoji']} 饭否 · {period['label']}实时推荐"}, "template": "orange"},
"elements": elements
}

View File

@ -1,56 +0,0 @@
agent:
name: "TestAgent"
model: "glm-5.2"
provider: "openai"
base_url: "https://ai-api.d-robotics.cc/v1"
temperature: 0.3
max_tokens: 16384
git:
default_branch: "main"
clone_depth: 50
max_file_size_kb: 500
analysis:
supported_languages:
- python
- typescript
- javascript
- go
- java
ignore_patterns:
- "**/node_modules/**"
- "**/__pycache__/**"
- "**/.git/**"
- "**/dist/**"
- "**/build/**"
- "**/vendor/**"
- "**/*.min.js"
- "**/*.bundle.js"
test_generation:
output_dir: "tests"
domain_layer_dir: "tests/domain"
infrastructure_layer_dir: "tests/infrastructure"
session_domain_dir: "tests/session"
smoke_marker: "smoke"
integration_marker: "integration"
regression_marker: "regression"
e2e_marker: "e2e"
metrics_gate:
min_coverage: 60
min_pass_rate: 95
backend:
host: "0.0.0.0"
port: 5002
existing_tests_root: "./tests"
plugins:
enabled:
- pylint_analyzer
- test_runner
logging:
level: "info"
format: "%(asctime)s [%(levelname)s] %(name)s: %(message)s"

View File

@ -5,7 +5,6 @@ Supports both D-Cloud and Robogo platforms.
import os import os
import random import random
import sys import sys
import uuid
from pathlib import Path from pathlib import Path
from typing import Dict, Type from typing import Dict, Type
from urllib.parse import urlparse from urllib.parse import urlparse
@ -78,10 +77,6 @@ class BaseConfig:
LOGIN_URL = "" LOGIN_URL = ""
# Robogo 认证
AUTH_TOKEN: str = os.getenv("AUTH_TOKEN", "")
COOKIE: str = os.getenv("AUTH_COOKIE", "")
DEFAULT_TIMEOUT: int = 15000 DEFAULT_TIMEOUT: int = 15000
SHORT_WAIT: int = 200 SHORT_WAIT: int = 200
MEDIUM_WAIT: int = 500 MEDIUM_WAIT: int = 500
@ -105,73 +100,32 @@ class BaseConfig:
REPORT_DIR: str = "tests/features/reports" REPORT_DIR: str = "tests/features/reports"
# Robogo resources # Robogo resources
FOLDER_NAME = f"UI_TEST_{uuid.uuid4().hex[:8]}" FOLDER_NAME = f"UI_TEST_{random.randint(1, 1000000)}"
DEV_MACHINE_NAME = f"UI_TEST_{uuid.uuid4().hex[:8]}" DEV_MACHINE_NAME = f"UI_TEST_{random.randint(1, 1000000)}"
DEV_MACHINE_SKU = "sku-e154fd3a-4719-db77-3911-21c6355349ec" DEV_MACHINE_SKU = "sku-e154fd3a-4719-db77-3911-21c6355349ec"
SSH_PUBLIC_KEY = os.getenv("SSH_PUBLIC_KEY", "") SSH_PUBLIC_KEY = "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIBGp6Be0pt0Xy3Ipxm+AQTz6JQq8DAzIU6XHqD+/gzH6"
SYSTEM_DISK = "100" SYSTEM_DISK = "100"
CLOUD_DESKTOP_SKU = "desktop-5880gpu12g-16c32g" CLOUD_DESKTOP_SKU = "desktop-5880gpu12g-16c32g"
CLOUD_DESKTOP_NAME = f"UI_TEST_{uuid.uuid4().hex[:8]}" CLOUD_DESKTOP_NAME = f"UI_TEST_{random.randint(1, 1000000)}"
MIRROR_NAME = f"UI_TEST_{uuid.uuid4().hex[:8]}" MIRROR_NAME = f"UI_TEST_{random.randint(1, 1000000)}"
MIRROR_SKU = "desktop-5880gpu12g-16c32g" MIRROR_SKU = "desktop-5880gpu12g-16c32g"
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
TEST_DATA_DIR = os.path.join(BASE_DIR, "test_data")
TEST_FILE = os.path.join(TEST_DATA_DIR, "Fruits-15.zip")
INSPECTION_INTERVAL = 300 INSPECTION_INTERVAL = 300
WAIT = { WAIT = {
'create': 60, 'create': 60,
'stop': 30, 'stop': 30,
'start': 30,
'switch': 15,
'delete': 30 'delete': 30
} }
class CloudDesktop:
POST_IMAGE_ID = os.getenv("CD_POST_IMAGE_ID", "")
PRE_IMAGE_ID = os.getenv("CD_PRE_IMAGE_ID", "")
BP_IMAGE_ID = os.getenv("CD_BP_IMAGE_ID", "")
SKU_ID = os.getenv("CD_SKU_ID", "desktop-5880gpu12g-16c32g")
DISK_SIZE = os.getenv("CD_DISK_SIZE", "100")
SPEC_ID = os.getenv("CD_SPEC_ID", "")
TIMER_ID = os.getenv("CD_TIMER_ID", "")
PRICE_POLICY_ID = os.getenv("CD_PRICE_POLICY_ID", "")
class DevMachine:
IMAGE_ID = os.getenv("DM_IMAGE_ID", "")
SKU_ID = os.getenv("DM_SKU_ID", "sku-e154fd3a-4719-db77-3911-21c6355349ec")
SSH_KEY = os.getenv("DM_SSH_KEY", "")
DISK_SIZE = os.getenv("DM_DISK_SIZE", "100")
CLOUD_AUTH_TOKEN: str = os.getenv("CLOUD_AUTH_TOKEN", "")
AMAP_KEY: str = os.getenv("AMAP_KEY", "")
AMAP_COORDINATES: str = os.getenv("AMAP_COORDINATES", "")
DEBUG: bool = False DEBUG: bool = False
PLATFORM_PORT = int(os.getenv("PLATFORM_PORT", "5001")) PLATFORM_PORT = int(os.getenv("PLATFORM_PORT", "5001"))
LARK_WEBHOOK = os.getenv("LARK_WEBHOOK_URL", "") LARK_WEBHOOK = os.getenv("LARK_WEBHOOK_URL", "")
class RobogoConfig(BaseConfig):
"""Robogo (ToC) 专用配置 — 覆盖 BaseConfig 的 Robogo 默认值"""
_ENV = os.getenv("ROBOGO_ENV", "PROD").upper()
if _ENV in ["FAT"]:
BASE_URL = "https://robogo-fat.d-robotics.cc"
else:
BASE_URL = "https://robogo.d-robotics.cc"
LOGIN_URL = f"{BASE_URL}/cloud-desktop/login"
DEFAULT_TIMEOUT = 30000
# Backward-compatible Config alias for framework/ code
Config = RobogoConfig
class DevConfig(BaseConfig): class DevConfig(BaseConfig):
BASE_URL = _normalize_base_url(os.getenv("BASE_URL", "https://cloud-fat.d-robotics.cc")) BASE_URL = _normalize_base_url(os.getenv("BASE_URL", "https://cloud-fat.d-robotics.cc"))
SSO_URL = os.getenv("SSO_URL", "https://sso-fat.d-robotics.cc") SSO_URL = os.getenv("SSO_URL", "https://sso-fat.d-robotics.cc")

40
docker-compose.yml Normal file
View File

@ -0,0 +1,40 @@
# Docker Compose for Unified Test Platform
# Usage:
# docker compose build # Build image
# docker compose run tests # Run all tests
# docker compose run --rm tests pytest -m smoke
# docker compose run --rm tests pytest tests/data_space/ -v
# docker compose up platform # Start the web platform
version: "3.9"
services:
tests:
build: .
image: unified-test-platform:latest
volumes:
- ./reports:/app/reports
- ./logs:/app/logs
- ./screenshots:/app/screenshots
- ./.auth:/app/.auth
env_file:
- .env
stdin_open: true
tty: true
platform:
build: .
image: unified-test-platform:latest
command: python -m backend.app
ports:
- "5001:5001"
volumes:
- ./reports:/app/reports
- ./logs:/app/logs
- ./screenshots:/app/screenshots
- ./.auth:/app/.auth
- ./backend/db.json:/app/backend/db.json
env_file:
- .env
stdin_open: true
tty: true

View File

@ -1,178 +0,0 @@
# Agent 工作流文档
## 一、5 步流水线
```
┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
│ 1.拉取代码│ → │ 2.代码分析│ → │ 3.领域提取│ → │ 4.Prompt │ → │ 5.LLM生成 │
│ git clone │ │ AST解析 │ │ DDD建模 │ │ SOUL+技能 │ │ 测试用例 │
└──────────┘ └──────────┘ └──────────┘ └──────────┘ └──────────┘
```
### 步骤 1:拉取代码
- 调用 `git_ops.clone_or_pull()`
- 克隆到 `work/<repo_name>/` 目录
- 检测语言(Python/TypeScript/Go/Java)
- 检测框架(FastAPI/Flask/Django/React/Vue 等)
- 收集源码文件列表(排除 node_modules、__pycache__ 等)
### 步骤 2:代码分析
- Python:AST 全量解析,提取类/函数/方法/导入/装饰器/docstring
- TypeScript/JS:正则提取类/函数/导入
- 构建调用图
### 步骤 3:DDD 领域提取
- 按目录分组识别限界上下文
- 识别聚合根/实体/值对象/领域服务/仓储
- 提取 docstring 作为统一语言术语表
- 识别共享内核(抽象基类/接口/Mixin)
### 步骤 4:Prompt 组装
- 系统 Prompt = SOUL.md + 4 个 Skill 知识库 + 领域模型
- 用户 Prompt = 文件代码上下文 + 测试类型 + 生成要求
### 步骤 5:LLM 生成
- 调用 LLM API 生成测试代码
- 解析代码块,提取测试文件
- 写入 `output/<repo_id>/` 目录
**验证结果:** 实测 `agent/llm_client.py` 生成 13408 字符完整测试文件。
---
## 二、精确回归模式
```
git diff --name-only HEAD~3
→ 变更文件列表
→ 映射到限界上下文
→ 只生成受影响上下文的回归测试
→ 自动筛选关联用例
```
**使用方式:**
```bash
# CLI
python3 main.py diff -r <repo-url> -a HEAD~3
# Web:仓库管理 → 展开仓库 → 点击「精确回归」
```
---
## 三、UI 变更检查 + 自动修复
### 3.1 仓库管理 - 分支自动检测
```
输入 Git 仓库 URL
→ 失焦/点击「最新分支」按钮
→ git ls-remote --heads 获取所有远程分支
→ git for-each-ref --sort=-committerdate 找到最新提交分支
→ 自动切换到最新分支
→ 显示分支列表(数量 + commit hash + 最新/默认标签)
→ 点击「扫描」→ clone → AST 分析 → DDD 建模
```
**分支功能:**
- 自动检测:失焦后自动扫描远程分支
- 手动检测:点击「⚡最新分支」按钮,自动找到最近提交的分支并切换
- 下拉列表:显示所有分支 + commit hash 前 8 位 + 最新/默认标签
- 分支对比:POST /api/repos/compare 对比任意两个分支的变更文件
### 3.2 检测模式(仓库管理 + 已有用例 Robogo 板块均支持)
```
输入前端仓库 URL
→ 克隆前端代码
→ 提取 Robogo 脚本中所有 UI 选择器
→ 与前端代码全文比对
→ 生成匹配/未匹配报告
```
### 3.2 自动修复模式(一键全自动)
```
输入前端仓库 URL
↓
1. 克隆前端代码
2. 提取 Robogo 选择器 + 比对
3. 备份原文件到 framework/business_backup/
4. LLM 逐个文件精准修复(含原始代码,只改失效行)
5. 覆盖原文件
6. 自动运行受影响场景验证
7. 实时 SSE 日志流展示全过程
```
**实测验证:**
- 57 个失效选择器 → 10 个文件 → LLM 精准修复
- 示例:`"button.loginBtn"` → `"button[type='submit']"`(只改 1 行,其他 65 行不变)
- 修复后导入验证:`Import OK`
### 3.3 提取的选择器类型
- `page.locator('...')` — CSS 选择器
- `page.get_by_text('...')` — 文本内容
- `page.get_by_placeholder('...')` — 占位符
- `page.get_by_role('...')` — ARIA 角色
- `input[placeholder*='...']` — CSS 属性选择器
- `button.className` — CSS 类名
**前端搜索策略:**
1. 精确匹配:选择器值直接出现在前端代码中
2. 模糊匹配:className/id/placeholder/aria-label/text 标签中的值
**输出报告:**
- `platform_reports/<id>_ui_report.md` — 匹配率统计 + 未匹配选择器列表
- `platform_reports/<id>_ui_suggestions.md` — LLM 修复建议
---
## 四、任务执行流程
### 4.1 D-Cloud 测试执行
```
POST /api/tasks { task_type: "run_existing", platform: "dcloud", module: "data_space" }
→ 后台线程启动
→ subprocess: pytest tests/data_space/ -v --tb=short
→ stdout 实时推送到 SSE 日志流
→ 完成后保存报告
```
### 4.2 Robogo 场景执行
```
POST /api/tasks { task_type: "run_existing", platform: "robogo", module: "robogo" }
→ 后台线程启动
→ subprocess: python3 framework/scripts/run_all.py
→ 注入环境变量: TEST_USERNAME, TEST_PASSWORD, ROBOGO_ENV, ROBOGO_SCOPE
→ stdout 实时推送到 SSE 日志流
```
### 4.3 仓库扫描 + 生成
```
POST /api/repos { url: "https://...", api_key: "sk-xxx" }
→ 后台线程启动
→ clone repo → AST 分析 → DDD 建模 → 存入 repos_db
→ 用户点击「生成」→ LLM 生成测试 → 写入 output/
```
---
## 五、生成的测试目录结构
```
output/<repo_id>/
├── domain/ # 领域层测试(Mock 隔离)
│ └── {context_name}/
│ ├── test_entities.py
│ ├── test_value_objects.py
│ ├── test_services.py
│ └── test_aggregates.py
├── infrastructure/ # 基础设施层测试
│ └── {context_name}/
│ ├── test_repositories.py
│ └── test_api.py
├── session/ # Session 领域测试
│ ├── test_session_lifecycle.py
│ └── test_session_context.py
├── smoke/ / integration/ / e2e/ # 分层测试
├── conftest.py # 全局 fixtures
└── domain_report.md # DDD 领域分析报告
```

View File

@ -1,309 +0,0 @@
# TestAgent API 文档
Base URL: `http://localhost:5002`
## 认证
当设置了 `PLATFORM_API_TOKEN` 环境变量时,所有 API 请求(`/api/health` 除外)必须在请求头中携带 Bearer Token:
```
Authorization: Bearer <your-token>
```
未设置 `PLATFORM_API_TOKEN` 时认证关闭(仅开发模式推荐)。
## 速率限制
以下 POST 端点受速率限制保护(按客户端 IP,滑动窗口):
| 端点 | 限制 |
|------|------|
| `POST /api/repos` | 10 次/60 秒 |
| `POST /api/repos/compare` | 10 次/60 秒 |
| `POST /api/repos/<id>/full` | 5 次/60 秒 |
| `POST /api/repos/check-ui` | 5 次/60 秒 |
| `POST /api/repos/fix-ui` | 5 次/60 秒 |
| `POST /api/tasks` | 10 次/60 秒 |
超过限制返回 `429 Too Many Requests`。
## SSRF 防护
所有接受 Git URL 的端点(`POST /api/repos`、`GET /api/repos/branches`、`POST /api/repos/compare`、`POST /api/repos/check-ui`、`POST /api/repos/fix-ui`、`POST /api/repos/<id>/full`)均执行 URL 校验:
- 仅允许 HTTPS 协议(拒绝 `git://`、`ssh://`、`git@` 等)
- 拒绝内网 IP 地址(10.x / 172.16-31.x / 192.168.x / 169.254.x / 127.x / ::1 / fc00:: / fe80::)
---
## 系统
### GET /api/health
健康检查。
**响应:**
```json
{
"status": "ok",
"version": "1.0.0",
"tasks_count": 10,
"reports_count": 8,
"repos_count": 0
}
```
---
## 控制台
### GET /api/dashboard/stats
获取控制台统计概览。
**响应:**
```json
{
"tasks": { "total": 10, "pass": 5, "fail": 3, "running": 2, "pass_rate": 50.0 },
"reports": { "total": 8, "pass": 5, "pass_rate": 62.5 },
"repos": { "total": 0 },
"existing_tests": { "modules": 35 }
}
```
---
## 仓库分支
### GET /api/repos/branches?url=<repo-url>
获取远程仓库所有分支列表,自动识别最新提交分支。
**响应:**
```json
{
"branches": [{"name": "dev", "commit": "8c45c92"}, {"name": "main", "commit": "6f6053f"}],
"total": 15,
"default": "main",
"latest": "dev"
}
```
### POST /api/repos/compare
对比两个分支的变更文件列表。
**请求体:**
```json
{
"url": "https://github.com/user/repo.git",
"base": "main",
"compare": "dev"
}
```
**响应:**
```json
{
"base": "main",
"compare": "dev",
"changed_files": ["agent/llm_client.py", "backend/app.py"],
"total_changes": 2
}
```
---
## 仓库管理
### GET /api/repos
获取所有已扫描仓库列表。
### POST /api/repos
扫描新仓库(clone + AST 分析 + DDD 建模)。
**请求体:**
```json
{
"url": "https://github.com/user/repo.git",
"branch": "main"
}
```
> **注意**:`api_key` 字段仅用于内存传递,不会持久化到数据库。也可通过 `DEEPSEEK_API_KEY` 环境变量配置。
### DELETE /api/repos/<repo_id>
删除仓库。
### POST /api/repos/<repo_id>/analyze
DDD 领域分析。
### POST /api/repos/<repo_id>/generate
生成测试用例。
**请求体:**
```json
{
"test_types": ["smoke", "unit", "integration"]
}
```
> **注意**:`api_key` 字段仅用于内存传递,不会持久化到数据库。也可通过 `DEEPSEEK_API_KEY` 环境变量配置。
### POST /api/repos/<repo_id>/diff
精确回归(仅对 git diff 变更文件生成测试)。
**请求体:**
```json
{
"against": "HEAD~1"
}
```
> **注意**:`api_key` 字段仅用于内存传递,不会持久化到数据库。也可通过 `DEEPSEEK_API_KEY` 环境变量配置。
### POST /api/repos/<repo_id>/full
全流程(扫描 + 分析 + 生成)。
### POST /api/repos/check-ui
UI 变更检查(克隆前端仓库,比对 Robogo 脚本中的 UI 选择器)。
**请求体:**
```json
{
"url": "https://gitea.d-robotics.cc/d-cloud/d_cloud_artificer_frontend",
"branch": "main"
}
```
> **注意**:`api_key` 字段仅用于内存传递,不会持久化到数据库。也可通过 `DEEPSEEK_API_KEY` 环境变量配置。
### POST /api/repos/fix-ui
UI 自动修复(检测 + 备份 + LLM 修复 + 覆盖原文件 + 重新测试验证)。
**请求体:**
```json
{
"url": "https://gitea.d-robotics.cc/d-cloud/d_cloud_artificer_frontend",
"branch": "main"
}
```
> **注意**:`api_key` 字段仅用于内存传递,不会持久化到数据库。也可通过 `DEEPSEEK_API_KEY` 环境变量配置。
**流程:** 克隆前端 → 提取选择器 → 比对 → 备份 → LLM 分批修复 → 覆盖 → 运行验证
---
## 任务管理
### GET /api/tasks
获取所有任务列表。支持 `?product=` 过滤。
### POST /api/tasks
创建并启动任务。
**请求体:**
```json
{
"name": "任务名称",
"task_type": "run_existing",
"platform": "dcloud",
"module": "data_space",
"test_marker": "smoke",
"test_file": "tests/data_space/tests/test_data_space_e2e.py",
"headless": "false",
"env": "PROD",
"scope": "all"
}
```
> **注意**:`api_key`、`account`、`password` 字段仅用于内存传递,不会持久化到数据库。建议通过 `.env` 环境变量配置凭据。
**任务类型 (task_type):**
| 值 | 说明 |
|----|------|
| `scan` | 扫描仓库 |
| `analyze` | DDD 分析 |
| `generate` | 生成测试 |
| `repo_full` | 全流程 |
| `diff` | 精确回归 |
| `run_existing` | 运行已有用例 |
| `ui_check` | UI 变更检查 |
### DELETE /api/tasks/<tid>
删除任务。
### POST /api/tasks/<tid>/stop
停止运行中的任务(发送 SIGKILL)。
### GET /api/tasks/<tid>/logs
SSE 日志流。实时推送任务执行日志。
**Event 格式:**
```
data: {"ts":"14:21:11","level":"INFO","msg":"执行: pytest ..."}
data: {"ts":"14:21:11","level":"SUCCESS","msg":"测试通过"}
data: {"level":"PING","msg":"","ts":"--:--:--"}
data: {"level":"DONE","msg":"","ts":"--:--:--"}
```
---
## 测试报告
### GET /api/reports
获取所有报告列表。
### GET /api/reports/<tid>
获取报告详情(含日志、结果、截图)。
---
## 已有用例
### GET /api/existing-tests/modules
获取已有用例模块列表。
**响应:**
```json
{
"dcloud": [
{
"name": "data_space",
"path": "tests/data_space",
"test_files": [
{
"name": "test_data_space_e2e.py",
"tests": [
{ "name": "test_dataspace_full_pipeline", "readable": "dataspace full pipeline", "doc": "创建→列表→文件→文件夹→删除" }
],
"count": 10
}
],
"test_count": 80
}
],
"robogo": [
{
"name": "robogo",
"label": "Robogo 全量巡检",
"description": "串行运行全部 13 个场景脚本",
"section": "product"
}
]
}
```
### GET /api/existing-tests/markers
获取所有 pytest 标记列表。
**响应:**
```json
["smoke", "e2e", "api", "ui", "flow", "data_space", "dataspace", ...]
```
---
## 静态资源
### GET /artifacts/screenshots/<filename>
获取测试截图。
### GET /<path>
SPA 前端(所有非 API 路径自动 fallback 到 index.html)。

View File

@ -1,140 +0,0 @@
# TestAgent 平台架构
## 一、架构总览
```
┌──────────────────────────────────────┐
│ React SPA (Vite 8) │
│ Dashboard / Repos / Tasks / Reports │
│ /existing (已有用例) │
└────────────────┬─────────────────────┘
│ HTTP + SSE
┌────────────────▼─────────────────────┐
│ Flask Backend (端口 5002) │
│ API 路由 / 任务调度 / SSE 日志流 │
└────────────────┬─────────────────────┘
│
┌──────────────────────┼──────────────────────┐
│ │ │
┌─────────▼─────────┐ ┌────────▼────────┐ ┌─────────▼─────────┐
│ agent/ (引擎) │ │ tests/ + │ │ main.py (CLI) │
│ LLM + Git + AST │ │ framework/ │ │ run/diff/analyze │
│ DDD + 测试生成 │ │ 900+ 已有用例 │ │ │
└───────────────────┘ └─────────────────┘ └───────────────────┘
```
## 二、项目目录
```
test-agent/
├── main.py # CLI 入口 (Click)
├── config.yaml # 全局配置
├── SOUL.md # Agent 角色定义
├── .env # 环境变量
├── requirements.txt # Python 依赖
│
├── agent/ # 核心引擎
│ ├── app.py # 编排器 (5 步流水线)
│ ├── llm_client.py # LLM 客户端 (OpenAI 兼容)
│ ├── git_ops.py # Git 仓库操作
│ ├── code_analyzer.py # AST 代码分析
│ ├── domain_extractor.py # DDD 领域模型提取
│ ├── prompt_builder.py # Prompt 组装
│ ├── test_generator.py # 测试生成 + 解析
│ └── ui_analyzer.py # UI 选择器变更分析
│
├── backend/ # Flask 后端
│ ├── app.py # API 路由 + 任务调度 + SSE
│ └── __main__.py # 启动入口
│
├── frontend/ # React SPA
│ ├── src/
│ │ ├── App.tsx # 路由配置
│ │ ├── components/
│ │ │ ├── layout/ # Layout + Sidebar + navConfig
│ │ │ ├── dashboard/ # 控制台
│ │ │ ├── repos/ # 仓库管理
│ │ │ ├── tasks/ # 任务管理
│ │ │ ├── reports/ # 测试报告
│ │ │ └── existing/ # 已有用例
│ │ ├── hooks/useTaskLogs.ts # SSE 日志流
│ │ └── context/ThemeContext.tsx # 暗色/亮色主题
│ └── dist/ # 生产构建产物
│
├── skills/ # 知识库
│ ├── tdd-methodology/SKILL.md # TDD 方法论
│ ├── ddd-patterns/SKILL.md # DDD 领域模式
│ ├── test-framework/SKILL.md # 测试框架规范
│ └── language-patterns/SKILL.md # 多语言测试模式
│
├── plugins/ # 插件系统
│ ├── pylint_analyzer/ # 代码静态分析
│ └── test_runner/ # 测试运行 + 门禁检查
│
├── tests/ # D-Cloud 测试用例 (22 模块)
├── framework/ # Robogo 场景脚本 (13 个)
├── config/ # 配置管理
├── templates/ # 测试模板
├── output/ # LLM 生成的测试
├── work/ # Git 仓库克隆目录
├── platform_reports/ # 测试报告存储
└── platform_artifacts/ # 截图等制品
```
## 三、技术栈
| 层 | 技术 | 版本 |
|----|------|------|
| 前端框架 | React | 19 |
| 类型系统 | TypeScript | 6 |
| 构建工具 | Vite | 8 |
| CSS 框架 | TailwindCSS | 4 |
| 路由 | React Router | 7 |
| 图标 | Lucide React | 1.23 |
| 后端框架 | Flask | 3 |
| 实时通信 | Server-Sent Events (SSE) | - |
| LLM | DeepSeek V4 Pro (LiteLLM Gateway) | - |
| 测试框架 | Pytest + Playwright | - |
| 代码分析 | Python AST | stdlib |
| Git 操作 | GitPython | 3.1 |
| 模板引擎 | Jinja2 | 3.1 |
| CLI 框架 | Click + Rich | 8.1 |
## 四、代码量统计
| 层 | 语言 | 行数 | 文件数 |
|----|------|------|--------|
| Agent 引擎 | Python | 1,200+ | 8 |
| 后端 API | Python | 920+ | 1 |
| 前端组件 | TypeScript | 3,000+ | 15 组件 |
| 知识库 | Markdown | 200+ | 4 |
| 测试模板 | Jinja2 | 50+ | 2 |
| 已有测试 | Python | 30,000+ | 73 文件 |
## 四、数据持久化
| 数据 | 存储位置 | 格式 |
|------|---------|------|
| 任务/仓库/报告 | `platform_db.json` | JSON |
| 任务日志 | `platform_reports/<task_id>.json` | JSON |
| 生成测试 | `output/<repo_id>/` | Python 文件 |
| 截图 | `platform_artifacts/screenshots/` | PNG |
| 前端构建产物 | `frontend/dist/` | HTML/JS/CSS |
| Git 仓库 | `work/` | 原始文件 |
## 五、核心设计模式
### 5.1 插件系统
仿照 hermes-bot 的插件架构,支持 `pre_analysis` 和 `post_generation` 钩子。
### 5.2 知识库 (Skills)
Skill 文件采用 Markdown 格式,与 hermes-bot 的 SKILL.md 模式一致,作为 LLM 的上下文注入。
### 5.3 SSE 实时日志
后端通过 `queue.Queue` 收集任务日志,前端通过 `EventSource` 实时接收,支持 PING 心跳保活。
### 5.4 任务调度
- 支持 `once` / `continuous` / `hourly` / `daily` / `weekly` 调度类型
- 30 秒轮询检查
- 窗口时间门控(如 `09:00-18:00`)
- 自动清理超过 100 个旧任务

View File

@ -1,247 +0,0 @@
# TestAgent 配置文档
## 一、config.yaml
```yaml
agent:
name: "TestAgent"
model: "glm-5.2" # LLM 模型名称
provider: "openai" # OpenAI 兼容
base_url: "https://ai-api.d-robotics.cc/v1"
temperature: 0.3
max_tokens: 16384
git:
default_branch: "main"
clone_depth: 50 # git clone 深度
max_file_size_kb: 500
analysis:
supported_languages: # 支持的语言
- python
- typescript
- javascript
- go
- java
ignore_patterns: # 忽略的文件/目录
- "**/node_modules/**"
- "**/__pycache__/**"
- "**/.git/**"
- "**/dist/**"
- "**/build/**"
- "**/vendor/**"
- "**/*.min.js"
- "**/*.bundle.js"
test_generation:
output_dir: "tests" # 测试输出目录
domain_layer_dir: "tests/domain"
infrastructure_layer_dir: "tests/infrastructure"
session_domain_dir: "tests/session"
smoke_marker: "smoke"
integration_marker: "integration"
regression_marker: "regression"
e2e_marker: "e2e"
metrics_gate: # 指标门禁
min_coverage: 60 # 覆盖率 ≥ 60%
min_pass_rate: 95 # 通过率 ≥ 95%
backend:
host: "0.0.0.0"
port: 5002
existing_tests_root: "./tests"
plugins:
enabled:
- pylint_analyzer # 代码静态分析
- test_runner # 测试运行 + 门禁
logging:
level: "info"
format: "%(asctime)s [%(levelname)s] %(name)s: %(message)s"
```
---
## 二、.env 环境变量
```bash
# LLM API 配置(固定,页面无需输入)
OPENAI_API_KEY=sk-your-api-key-here
OPENAI_BASE_URL=https://ai-api.d-robotics.cc/v1
# 测试平台登录凭证
TEST_USERNAME=admin&tsting # 地瓜机器人平台账号
TEST_PASSWORD=12345678 # 对应密码
```
**可选环境变量:**
| 变量 | 说明 | 默认值 |
|------|------|--------|
| `DEEPSEEK_API_KEY` | DeepSeek API Key(兼容模式) | - |
| `ANTHROPIC_API_KEY` | Anthropic API Key | - |
| `HEADLESS` | 浏览器无头模式 | `false` |
| `PLATFORM_API_TOKEN` | API 认证 Token(留空则关闭认证) | - |
| `FLASK_ENV` | Flask 运行环境(development/production) | `development` |
| `CORS_ORIGINS` | CORS 允许来源(逗号分隔) | `http://localhost:5174,...` |
| `TASK_TIMEOUT_SECONDS` | 单任务最大运行时间(秒) | `3600` |
| `SSH_PUBLIC_KEY` | SSH 公钥(原硬编码迁移) | - |
| `DM_SSH_KEY` | 开发机 SSH Key(原硬编码迁移) | - |
---
## 三、Skills 知识库配置
知识库位于 `skills/` 目录,每个 Skill 是一个子目录,包含 `SKILL.md` 文件。
### 3.1 TDD 方法论 (`skills/tdd-methodology/SKILL.md`)
- 红-绿-重构循环
- FIRST 原则(Fast/Independent/Repeatable/Self-Validating/Timely)
- AAA 模式(Arrange-Act-Assert)
- 测试命名规范
- 测试替身(Stub/Mock/Fake/Spy/Dummy)
### 3.2 DDD 模式 (`skills/ddd-patterns/SKILL.md`)
- 限界上下文划分
- 聚合根/实体/值对象/领域服务/仓储
- 测试目录结构规范
- 领域层 vs 基础设施层隔离
- Session 领域测试
### 3.3 测试框架规范 (`skills/test-framework/SKILL.md`)
- 测试分层(冒烟/集成/系统/回归/指标)
- 测试标记规范
- 指标门禁断言
- CI/CD 流水线链
- 敏捷迭代规范
### 3.4 多语言模式 (`skills/language-patterns/SKILL.md`)
- Python (pytest + Mock)
- TypeScript (Jest)
- Go (testing)
- 测试数据管理
---
## 四、插件配置
### 4.1 pylint_analyzer
- 触发时机:`pre_analysis`
- 功能:行长度检测、TODO/FIXME 标记、print 语句检测、复杂度评估
### 4.2 test_runner
- 触发时机:`post_generation`
- 功能:运行生成的测试、解析结果、指标门禁检查
---
## 五、前端配置
### 5.1 vite.config.ts
```typescript
export default defineConfig({
plugins: [react(), tailwindcss()],
server: {
host: '0.0.0.0',
port: 5174,
proxy: {
'/api': 'http://127.0.0.1:5002',
'/artifacts': 'http://127.0.0.1:5002',
},
},
})
```
### 5.2 主题配置
- 暗色/亮色模式切换
- CSS 自定义属性 14 个主题变量
- 存储在 `localStorage`,默认跟随系统偏好
---
## 六、数据清理策略
- 任务超过 100 个时自动清除最旧 50 个
- 清理时同步删除关联的截图和报告文件
- `platform_db.json` 每次写入时自动清理
---
## 七、安全加固配置(已实施)
### 7.1 API 认证
设置 `PLATFORM_API_TOKEN` 环境变量后,所有 API 请求(`/api/health` 豁免)需携带 `Authorization: Bearer <token>` 请求头:
```bash
export PLATFORM_API_TOKEN="your-secret-token"
```
前端请求示例:
```javascript
fetch('/api/repos', {
headers: { 'Authorization': 'Bearer your-secret-token' }
})
```
未设置时认证关闭(仅开发模式推荐)。
### 7.2 CORS 配置
通过 `CORS_ORIGINS` 环境变量配置允许的来源(逗号分隔)。生产环境(`FLASK_ENV=production`)启动时若未设置则输出警告:
```bash
export CORS_ORIGINS="https://your-domain.com"
export FLASK_ENV=production
```
### 7.3 SSRF 防护
所有接受 Git URL 的端点执行 URL 校验:
- 仅允许 HTTPS 协议(拒绝 `git://`、`ssh://`、`git@`)
- 拒绝内网 IP(10.x / 172.16-31.x / 192.168.x / 169.254.x / 127.x / ::1 / fc00:: / fe80::)
### 7.4 路径安全
所有文件路径参数(`test_file`、`module`)通过 `Path.resolve()` + `is_relative_to()` 校验,防止目录穿越攻击。
### 7.5 速率限制
关键 POST 端点按客户端 IP 实施滑动窗口速率限制(5-10 次/60 秒),超过返回 `429`。
### 7.6 API Key 保护
API Key 仅在内存中传递,不持久化到 `platform_db.json`。任务创建后 API Key 字段从数据库记录中移除。
### 7.7 异常信息保护
`@errorhandler(500)` 返回通用错误消息,内部异常详情仅写入日志,不返回客户端。
### 7.8 数据库原子写入
`platform_db.json` 使用 `tempfile.mkstemp` + `os.replace` 原子写入,防止进程崩溃时数据库损坏。
---
## 八、性能优化(已实施)
### 8.1 线程池
- `ThreadPoolExecutor(max_workers=4)` 限制并发任务执行,防止无限创建线程
### 8.2 任务超时
- `_enforce_proc_timeout()` 后台 Timer,超时自动 kill 进程组(默认 3600 秒)
### 8.3 日志轮转
- `RotatingFileHandler(maxBytes=10MB, backupCount=5)` 防止日志文件无限增长
### 8.4 httpx 连接池
- `LLMClient` 配置 `Limits(max_connections=10, max_keepalive_connections=5)`
### 8.5 随机名生成
- 资源名使用 `uuid.uuid4().hex[:8]` 替代 `random.randint()`,消除碰撞风险
### 8.6 前端优化
- SSE 日志限制保留 200 条
- `useTaskLogs` hook 统一管理 EventSource 生命周期,组件卸载自动清理
- 全局 `ErrorBoundary` 捕获渲染异常,防止白屏

View File

@ -1,132 +0,0 @@
# TestAgent 快速开始
## 前置条件
- Python 3.9+
- Node.js 18+ (pnpm)
- Git
## 1. 环境配置
```bash
# 创建 .env 文件
cat > .env << 'EOF'
OPENAI_API_KEY=sk-xxx
OPENAI_BASE_URL=https://llmgateway.d-robotics.cc/v1
TEST_USERNAME=your_username
TEST_PASSWORD=your_password
EOF
# 安装 Python 依赖
pip install -r requirements.txt
```
## 2. 前端构建
```bash
cd frontend
pnpm install
pnpm build
cd ..
```
## 3. 启动 Web 平台
```bash
python3 -m backend
# 访问 http://localhost:5002
```
## 4. CLI 命令行
```bash
# 扫描仓库并生成测试
python3 main.py run -r https://github.com/user/repo.git
# 精确回归(只对变更代码生成测试)
python3 main.py diff -r https://github.com/user/repo.git -a HEAD~3
# 仅 DDD 领域分析(不调用 LLM)
python3 main.py analyze -r https://github.com/user/repo.git
```
## 5. Web 平台页面
| 页面 | 路由 | 功能 |
|------|------|------|
| 控制台 | `/dashboard` | 统计概览 + 快速操作入口 |
| 仓库管理 | `/repos` | 添加 Git 仓库 → 扫描/分析/生成/回归 |
| 任务管理 | `/tasks` | 实时 SSE 日志流 + 停止/删除 |
| 测试报告 | `/reports` | 报告列表 + 详情 + 日志回放 |
| 已有用例 | `/existing` | 运行 D-Cloud 903 用例 + Robogo 13 场景 |
## 6. 仓库管理使用流程
```
1. 输入 Git 仓库 URL + 分支
2. 点击「扫描」→ 自动 clone + AST 分析 + DDD 建模
3. 展开仓库卡片 → 点击「生成测试」→ LLM 自动生成测试
4. 或点击「全流程」→ 一键完成扫描+分析+生成
```
## 7. 已有用例使用流程
### D-Cloud
```
1. 选择模块(如 E2E 全量测试)
2. 选择具体测试用例
3. 点击运行
```
### Robogo
```
1. 选择产品(Robogo 全量巡检 / 数据闭环)
2. 点击「配置并启动」
3. 填写产品/环境/范围/账号/密码
4. 点击「启动巡检」
```
## 8. API Key 配置
API Key 已固定在 `.env` 文件中,页面无需手动输入。
```bash
# .env
OPENAI_API_KEY=sk-your-api-key-here
OPENAI_BASE_URL=https://ai-api.d-robotics.cc/v1
```
## 9. 安全注意事项
### API Key 管理
- **切勿**将 API Key 硬编码在代码中或提交到 Git 仓库
- 使用 `.env` 文件管理敏感信息,并确保 `.env` 在 `.gitignore` 中
- 生产环境建议通过环境变量注入,而非文件
### 生产环境部署
- 确保 Flask `debug=False`(已在 `backend/__main__.py` 中设置)
- 配置适当的 CORS 白名单,不要开放 `origins='*'`
- 使用 HTTPS 保护 API 通信
- 定期清理 `platform_db.json` 中的敏感数据
## 10. 常见问题
### SSE 日志不显示
- 检查浏览器控制台是否有网络错误
- 确保后端服务正常运行
- 刷新页面后重试
### 前端构建失败
```bash
cd frontend
rm -rf node_modules pnpm-lock.yaml
pnpm install
pnpm build
```
### 数据库文件损坏
```bash
# 备份后重建
mv platform_db.json platform_db.json.bak
# 重启后端服务会自动创建新的数据库文件
```

View File

@ -1,111 +0,0 @@
# TDD + DDD 合规性报告
对照 `/Users/d-robotics/Desktop/unified-test-platform/api_docs/测试框架优化.md` 全部 15 项要求。
---
## 一、基础测试分层
| 规范 | 要求 | 实现 | 状态 |
|------|------|------|------|
| 冒烟测试 | 版本发布第一道轻量化校验,仅覆盖核心主流程 | `@pytest.mark.smoke` 标记,快速执行 | ✅ |
| 集成测试 | 多模块/跨服务/接口联动验证 | `@pytest.mark.integration` / `@pytest.mark.flow` 标记 | ✅ |
| 系统测试 | 完整产品黑盒全量验证,覆盖功能/边界/异常/兼容性/性能 | `@pytest.mark.system` 标记 | ✅ |
| 回归测试 | 三种策略:全量/精准选择性/冒烟轻量级 | `diff` 精确回归 + `@pytest.mark.regression` | ✅ |
| 指标测试 | 覆盖率≥60%、通过率≥95% 作为质量门禁 | conftest 自动注入门禁断言 | ✅ |
---
## 二、TDD 测试驱动开发
| 规范 | 要求 | 实现 | 状态 |
|------|------|------|------|
| 红-绿-重构循环 | 红:先写测试 → 绿:最小代码 → 重构:优化结构 | LLM 生成 AAA 模式测试,命名遵循 `test_should_xxx_when_xxx` | ✅ |
| 前置定义入参/出参/边界 | 强制前置定义,统一测试用例标准 | 每个测试函数有 docstring 描述意图 | ✅ |
| 拉高测试覆盖率 | 天然拉高覆盖率,支撑高频自动化回归 | 指标门禁:覆盖率 ≥ 60% | ✅ |
| 单元测试脚手架 | 内置脚手架,支持一键生成 TDD 基础用例模板 | `templates/unit_test.py.j2` + `templates/conftest.py.j2` | ✅ |
| 敏捷短迭代 | 每次代码提交自动执行存量测试 | CI 流水线自动触发 | ✅ |
**LLM 生成验证(实测):** 2 个源文件 → 48 个测试函数,898 行代码,34,577 字符,100% 含 AAA 模式 + should 命名 + docstring。
**LLM 生成示例:**
```python
class TestLLMConfig:
"""LLMConfig 数据类测试"""
def test_should_have_default_values(self):
"""验证默认配置项"""
# Arrange
config = LLMConfig()
# Act & Assert
assert config.provider == "deepseek"
assert config.model == "deepseek-chat"
def test_should_override_defaults_when_provided(self):
"""提供参数时应覆盖默认值"""
# Arrange
config = LLMConfig(provider="openai", temperature=0.5)
# Act & Assert
assert config.provider == "openai"
assert config.temperature == 0.5
```
---
## 三、DDD 领域驱动设计
| 规范 | 要求 | 实现 | 状态 |
|------|------|------|------|
| 限界上下文 | 按业务模块独立边界划分测试套件 | 代码扫描自动提取,测试按 `domain/{context}/` 组织 | ✅ |
| 聚合根/实体/领域服务 | 最小业务粒度定义测试用例 | 代码分析器自动识别 `Repository`/`Service`/`Entity`/`Aggregate` | ✅ |
| 统一语言 | 测试用例/缺陷/需求使用一致术语 | docstring 提取为术语表 `ubiquitous_language` | ✅ |
| 精准回归 | 代码变更绑定对应领域上下文,自动筛选 | `git diff` → 映射限界上下文 → 筛选关联用例 | ✅ |
| 领域层隔离 | 领域业务逻辑单元测试独立于基础设施层 | `tests/domain/` vs `tests/infrastructure/`,Mock 隔离 | ✅ |
**DDD 领域提取示例:**
```
限界上下文: agent
├── 聚合根: LLMClient
├── 实体: LLMConfig, LLMMessage, LLMResponse
├── 领域服务: GitOps, CodeAnalyzer, DomainExtractor
├── 值对象: GitRepoInfo, FileAnalysis, ClassInfo
└── 统一语言: {"chat": "发送聊天请求", "clone_or_pull": "克隆或拉取仓库"}
```
---
## 四、配套方法论
| 规范 | 要求 | 实现 | 状态 |
|------|------|------|------|
| 敏捷开发 | Sprint 增量交付,CI/CD 自动触发 | 任务调度 + 流水线自动触发 | ✅ |
| MDD 模型驱动 | 从模型自动生成 CRUD 基础代码和测试骨架 | 测试脚手架模板 + 代码生成插件 | ✅ |
| Head First | 设计直观,可视化报告,清晰分层,低学习成本 | Web 可视化平台,6 个页面直观操作 | ✅ |
---
## 五、Session 领域测试
| 规范 | 要求 | 实现 | 状态 |
|------|------|------|------|
| Session 容器 | 唯一 session_id + 用户身份 + 模型参数 + 上下文窗口 + 对话历史 + 系统提示词 | 独立 Session 领域测试套件 | ✅ |
| 测试覆盖 | 会话创建/历史持久化/上下文携带/清空历史/会话销毁 | 5 个生命周期全链路回归用例 | ✅ |
---
## 六、框架优化核心目标
| 目标 | 状态 |
|------|------|
| 以 DDD 划分测试套件,实现业务模块化管理、精准回归 | ✅ |
| 强制 TDD 开发规范,标准化用例产出 | ✅ |
| 流水线串联冒烟/集成/系统/回归全流程,配套指标测试门禁 | ✅ |
| 适配敏捷迭代,结合 MDD 减少重复测试代码编写 | ✅ |
| 针对 AI 对话、算力 Infra 垂类业务独立领域测试套件 | ✅ |
| 降低用例维护成本,自动化全覆盖,减少手工测试工作量 | ✅ |
---
## 七、合规结论
**15/15 项全部通过,TDD + DDD 规范完全覆盖。**

View File

@ -1,130 +0,0 @@
# 测试用例资产清单
## 一、D-Cloud 测试用例(22 模块,903 个测试函数)
### 按模块分布
| # | 模块 | 标记 | 用例数 | 测试文件 |
|---|------|------|--------|---------|
| 1 | data_generation | `data_generation` | 234 | 15 |
| 2 | data_space | `data_space or dataspace` | 155 | 7 |
| 3 | data_set | `dataset` | 80 | 9 |
| 4 | model_workshop | `model_workshop` | 80 | 6 |
| 5 | device_manage | `device_manage` | 58 | 3 |
| 6 | workbench | `workbench` | 34 | 3 |
| 7 | cloud_desktop | `cloud_desktop` | 20 | 4 |
| 8 | mirror_center | `mirror_center` | 20 | 4 |
| 9 | dev_machine | `dev_machine` | 13 | 4 |
| 10 | lora_finetune | `lora_finetune` | 20 | 3 |
| 11 | material_library | `material_library` | 20 | 3 |
| 12 | model_square | `model_square` | 20 | 3 |
| 13 | monitor | `monitor` | 20 | 3 |
| 14 | prompt_library | `prompt_library` | 20 | 3 |
| 15 | login | `login` | 15 | 2 |
| 16 | data | 基础 | 10 | 2 |
| 17 | base | 公共 | 8 | 2 |
| 18 | features | 特性 | 5 | 1 |
| 19 | fixtures | 夹具 | 5 | 1 |
| 20 | robogo | `robogo` | 3 | 1 |
| 21 | utils | 工具 | 2 | 1 |
| 22 | conftest | 配置 | 0 | 0 |
| **总计** | | | **903** | **73** |
### E2E 测试详情
#### API 全链路(8 条)
| 编号 | 名称 | 描述 | 测试路径 |
|------|------|------|---------|
| ① | 任务全链路 | 创建→列表→详情→停止→删除 | data_generation::test_full_pipeline_create_stop_delete |
| ② | 任务结果 | 创建→结果→详情→评价→删除 | data_generation::test_task_result_full_pipeline |
| ③ | 任务评测 | 创建→触发评测→停止评测 | data_generation::test_task_scoring_full_pipeline |
| ④ | LORA | 列表→创建→Pod→删除 | data_generation::test_lora_task_full_pipeline |
| ⑤ | 系统提示词 | 创建→详情→更新→列表→删除 | data_generation::test_system_prompt_full_pipeline |
| ⑥ | 工作流 | 创建→详情→更新→文件→删除 | data_generation::test_workflow_full_pipeline |
| ⑦ | 数据空间 | 创建→列表→文件→文件夹→删除 | data_generation::test_dataspace_full_pipeline |
| ⑧ | 跨模块组合 | 4 个列表接口组合调用 | data_generation::test_all_core_lists_return_ok |
#### UI 点击测试(3 条)
| 名称 | 描述 | 执行模式 |
|------|------|---------|
| 任务创建 | 点击创建→停止→删除 | 有头浏览器 |
| 数据空间 | 点击创建→删除空间 | 有头浏览器 |
| 跨模块导航 | 点击各模块 Tab 验证 | 有头浏览器 |
### 测试标记体系
| 标记 | 说明 |
|------|------|
| `smoke` | 冒烟测试(核心主流程) |
| `e2e` | 端到端测试 |
| `api` | API 接口测试 |
| `ui` | UI 交互测试 |
| `flow` | 流程/集成测试 |
| `login` | 登录相关测试 |
| `comprehensive` | 综合测试 |
| `real_creation` | 创建真实资源 |
| `flaky` | 已知不稳定(CI 自动重试) |
| `requires_cleanup` | 需要清理 fixture |
| `destructive` | 会修改/删除现有资源 |
| `external_dependency` | 依赖外部服务状态 |
---
## 二、Robogo 测试用例(13 个条目)
### 全量巡检
| 产品 | 描述 | 入口脚本 | 行数 |
|------|------|---------|------|
| Robogo 全量巡检 | 串行运行全部 13 个场景脚本 | `framework/scripts/run_all.py` | - |
| 数据闭环 | 端到端业务流水线验证 | `framework/scripts/run_data_loop.py` | - |
### 独立场景脚本
| # | 脚本 | 行数 | 状态 |
|---|------|------|------|
| 1 | compute_resource_scenario.py | - | ✅ |
| 2 | desktop_lifecycle.py | - | ✅ |
| 3 | file_system_scenario.py | - | ✅ |
| 4 | image_generation_scenario.py | - | ✅ |
| 5 | mirror_assets.py | - | ✅ |
| 6 | monkey_scenario.py | - | ✅ |
| 7 | openclaw_scenario.py | - | ✅ |
| 8 | quantization_scenario.py | - | ✅ |
| 9 | test_billing.py | - | ✅ |
| 10 | three_d_assets_scenario.py | - | ✅ |
| 11 | three_d_generation_scenario.py | - | ✅ |
---
## 三、LLM 生成的测试(Agent 输出)
| 源文件 | 生成文件 | 大小 | 行数 | 测试函数 | AAA | should |
|--------|---------|------|------|---------|-----|--------|
| agent/llm_client.py | test_llm_client.py | 23,857 | 652 | 35 | ✅ | ✅ |
| agent/git_ops.py | test_git_ops.py | 10,720 | 246 | 13 | ✅ | ✅ |
| **总计** | | **34,577** | **898** | **48** | | |
---
## 四、总览统计
| 平台 | 来源 | 数量 | 执行方式 |
|------|------|------|---------|
| D-Cloud | 已有用例 | 903 个测试函数 | pytest |
| Robogo | 已有用例 | 13 个场景脚本 | Python 脚本 |
| Agent 生成 | LLM 输出 | 48 个测试函数 | pytest |
| **总计** | | **964 个测试** | |
---
## 五、测试执行依赖
| 依赖 | 说明 | 配置位置 |
|------|------|---------|
| TEST_USERNAME | 地瓜机器人平台登录账号 | `.env` |
| TEST_PASSWORD | 对应密码 | `.env` |
| Playwright | 浏览器自动化(UI 测试) | pip install |
| Chromium | 浏览器引擎 | playwright install |
| OpenAI API Key | LLM 测试生成 | `.env` 或 Web 页面输入 |
| config/settings.py | 平台配置 | `config/` |

View File

@ -1,146 +0,0 @@
# TestAgent 验证报告
测试日期:2026-07-07 | 更新:2026-07-08 | Python 3.9.6 | LLM: glm-5.2
---
## 一、后端 API 验证 (19/19 通过)
| # | 端点 | 方法 | 状态码 | 结果 |
|---|------|------|--------|------|
| 1 | /api/health | GET | 200 | ✅ |
| 2 | /api/repos | GET | 200 | ✅ |
| 3 | /api/repos | POST | 200 | ✅ |
| 4 | /api/repos/<id>/analyze | POST | 200 | ✅ |
| 5 | /api/repos/<id>/generate | POST | 200 | ✅ |
| 6 | /api/repos/<id>/diff | POST | 200 | ✅ |
| 7 | /api/repos/<id>/full | POST | 200 | ✅ |
| 8 | /api/repos/check-ui | POST | 200 | ✅ |
| 9 | /api/repos/fix-ui | POST | 200 | ✅ |
| 10 | /api/tasks | GET | 200 | ✅ |
| 11 | /api/tasks | POST | 200 | ✅ |
| 12 | /api/tasks/<id>/stop | POST | 200 | ✅ |
| 13 | /api/tasks/<id>/logs | GET (SSE) | 200 | ✅ |
| 14 | /api/tasks/<id> | DELETE | 200 | ✅ |
| 15 | /api/reports | GET | 200 | ✅ |
| 16 | /api/reports/<id> | GET | 200 | ✅ |
| 17 | /api/reports/<id>/html | GET | 200 | ✅ |
| 18 | /api/existing-tests/modules | GET | 200 | ✅ |
| 19 | /api/existing-tests/markers | GET | 200 | ✅ |
| 20 | /api/dashboard/stats | GET | 200 | ✅ |
---
## 二、前端 SPA 验证 (6/6 页面)
| 页面 | 路由 | 状态码 | 结果 |
|------|------|--------|------|
| 首页 | `/` | 200 | ✅ |
| 控制台 | `/dashboard` | 200 | ✅ |
| 仓库管理 | `/repos` | 200 | ✅ |
| 任务管理 | `/tasks` | 200 | ✅ |
| 测试报告 | `/reports` | 200 | ✅ |
| 已有用例 | `/existing` | 200 | ✅ |
---
## 三、CLI 命令验证 (4/4)
| 命令 | 退出码 | 结果 |
|------|--------|------|
| `python3 main.py --help` | 0 | ✅ |
| `python3 main.py run --help` | 0 | ✅ |
| `python3 main.py diff --help` | 0 | ✅ |
| `python3 main.py analyze --help` | 0 | ✅ |
---
## 四、测试用例验证
### 4.1 Pytest 收集
```
903 tests collected in 0.20s
```
### 4.2 实际执行
| 指标 | 数值 |
|------|------|
| 通过 | 1 |
| 失败 | 1 (Playwright Timeout: .ant-table) |
| 跳过 | 2 |
| 耗时 | 69s |
### 4.3 Robogo 配置
- BASE_URL: https://cloud-fat.d-robotics.cc
- 13 个场景脚本可运行
---
## 五、Agent 全流程验证
### 5.1 代码扫描 + DDD + LLM 生成
| 指标 | 数值 |
|------|------|
| 分析文件 | 2 个 |
| 发现类 | 6 个 |
| 限界上下文 | 1 个 |
| LLM 生成测试 | 48 个函数, 898 行, 100% AAA + should 命名 |
### 5.2 UI 变更检查 + 自动修复
| 指标 | 数值 |
|------|------|
| 前端仓库 | typescript/Vue, 120 文件 |
| Robogo 选择器 | 270 个 |
| 匹配率 | 78.9% (213/270) |
| 失效选择器 | 57 个 |
| 涉及测试文件 | 10 个 |
| LLM 修复 | 精准 1 行修改 (loginBtn → button[type='submit']) |
| 验证 | Import OK |
### 5.3 精确回归
| 指标 | 数值 |
|------|------|
| 变更文件 | 5 个 |
| 限界上下文 | 1 个 |
| 生成回归测试 | ✅ |
---
## 六、HTML 报告
| 指标 | 数值 |
|------|------|
| 生成脚本 | scripts/generate_report.py(原平台) |
| 报告大小 | 622KB |
| 功能 | 圆环图 + 柱状图 + 历史趋势 + 筛选 + 截图嵌入 + 主题切换 |
---
## 七、修复的问题
| 问题 | 修复 |
|------|------|
| SPA 路由 404 | 移除 Flask static_folder |
| LLM 生成被截断 | 正则兜底 + max_tokens 16384 |
| 缺少 config/ | 从原平台复制 |
| 密码显示 sha256 | 移除哈希逻辑 |
| Robogo 走 pytest | 保存 platform 字段 |
| E2E 模块 0 用例 | 聚合扫描 |
| Robogo 只有 2 产品 | 拆分为 2+11 |
| 报告日志格式错误 | 字符串→对象转换 |
| 报告无 HTML 链接 | 调用原平台 generate_report.py |
| UI 修复只生成不覆盖 | 直接写入 framework/business/ + 备份 |
| LLM 修复重写文件 | 含原始代码精准修改 |
---
## 八、已知限制
| 项目 | 说明 |
|------|------|
| 部分用例需登录 | 依赖 TEST_USERNAME/TEST_PASSWORD |
| 浏览器依赖 | UI 测试需要 Playwright + Chromium |
| LLM 生成质量 | 取决于模型,复杂代码建议人工审核 |
| 大仓库扫描 | >1000 文件较慢 |
| 前端热更新 | 需重新 pnpm build |
| .ant-table 选择器 | 前端 UI 已变更,需运行 UI 修复 |

156
framework/bot.py Normal file
View File

@ -0,0 +1,156 @@
import re
import json
import threading
import concurrent.futures
from datetime import datetime
import lark_oapi as lark
from lark_oapi.api.im.v1 import (
CreateMessageRequest,
CreateMessageRequestBody,
)
from lark_oapi.event.callback.model.p2_card_action_trigger import P2CardActionTrigger
from framework.config.settings import Config as config
from framework.core.logger import get_logger
from framework.business.cloud_desktop import CloudDesktopService
from framework.business.dev_machine import DevMachineService
from framework.business.billing import BillingService
from framework.business.meal_reminder import MealReminderService
from framework.business.boilerplate import BoilerplateService
from framework.core.exceptions import TokenExpiredError
logger = get_logger("FeishuBot")
# ---------- 飞书卡片常量 ----------
TOKEN_UPDATE_CARD_ID = "AAq2uZZvyWY01"
RESULT_CARD_ID = "AAqKcs3OrZBnJ"
INTRO_CARD_ID = "AAq2uZZvyWY06"
# 线程池
executor = concurrent.futures.ThreadPoolExecutor(max_workers=10)
# ---------- 业务服务实例化 ----------
cd_service = CloudDesktopService()
dm_service = DevMachineService()
billing_service = BillingService()
meal_service = MealReminderService()
bp_service = BoilerplateService()
# ---------- 全局计数器 ----------
_counter_lock = threading.Lock()
_global_counter = 0
def _next_default_name() -> str:
global _global_counter
with _counter_lock:
_global_counter += 1
return f"验证{_global_counter:02d}"
# ---------- 飞书 API Client ----------
_lark_client = lark.Client.builder() \
.app_id(config.FEISHU_APP_ID) \
.app_secret(config.FEISHU_APP_SECRET) \
.build()
def send_feishu_message(chat_id: str, text: str):
body = CreateMessageRequestBody.builder().receive_id(chat_id).msg_type("text").content(json.dumps({"text": text})).build()
request = CreateMessageRequest.builder().receive_id_type("chat_id").request_body(body).build()
_lark_client.im.v1.message.create(request)
def send_card_json(chat_id: str, card_json: dict):
body = CreateMessageRequestBody.builder().receive_id(chat_id).msg_type("interactive").content(json.dumps(card_json)).build()
request = CreateMessageRequest.builder().receive_id_type("chat_id").request_body(body).build()
_lark_client.im.v1.message.create(request)
def _handle_single_task(chat_id, name, task_type):
try:
if task_type == "cd_post":
results, instance_id = cd_service.run_lifecycle_test(name, flow_type="postpaid_to_prepaid")
label = "云桌面(按转包)"
elif task_type == "cd_pre":
results, instance_id = cd_service.run_lifecycle_test(name, flow_type="prepaid_to_postpaid")
label = "云桌面(包转按)"
elif task_type == "bp":
results, instance_id = bp_service.run_lifecycle_test(name)
label = "样本工程"
else:
results, instance_id = dm_service.run_lifecycle_test(name)
label = "开发机"
send_feishu_message(chat_id, f"✅ {label} [{name}] 验证完成!")
except TokenExpiredError:
send_feishu_message(chat_id, "⚠️ 认证过期,请更新 Token")
except Exception as e:
logger.error(f"Task error: {e}")
send_feishu_message(chat_id, f"❌ {label} 验证异常: {e}")
def _parse_command(text: str):
patterns = {
"cd_post": r"robogo-云桌面[ \-:=]+(.+)$",
"cd_pre": r"robogo-云桌面包月[ \-:=]+(.+)$",
"dm": r"robogo-开发机[ \-:=]+(.+)$",
"bp": r"robogo-样本工程[ \-:=]+(.+)$",
"billing": r"账单[ \-:=]*(.*)$",
}
# 辅助匹配模式(不带名称的情况)
fallback_patterns = {
"cd_post": r"robogo-云桌面\s*$",
"cd_pre": r"robogo-云桌面包月\s*$",
"dm": r"robogo-开发机\s*$",
"bp": r"robogo-样本工程\s*$",
}
text_clean = text.strip()
logger.info(f"Parsing command from text: '{text_clean}'")
# 先试带有名称的模式
for cmd, p in patterns.items():
m = re.search(p, text_clean)
if m:
logger.info(f"Matched named pattern: {cmd}, name: {m.group(1).strip()}")
return cmd, m.group(1).strip()
# 再试默认模式
for cmd, p in fallback_patterns.items():
m = re.search(p, text_clean)
if m:
logger.info(f"Matched fallback pattern: {cmd}")
return cmd, None
logger.warning(f"No pattern matched for text: '{text_clean}'")
return None, None
def _on_message(data):
msg = data.event.message
chat_id = msg.chat_id
content = json.loads(msg.content)
text = content.get("text", "")
clean_text = re.sub(r'@[^ ]+', '', text).strip()
if "饭否" in clean_text:
send_card_json(chat_id, meal_service.build_card())
return
cmd, name = _parse_command(clean_text)
if cmd == "billing":
items = billing_service.fetch_billing_data(name)
send_feishu_message(chat_id, f"共找到 {len(items)} 条账单记录")
elif cmd:
name = name or _next_default_name()
executor.submit(_handle_single_task, chat_id, name, cmd)
else:
send_feishu_message(chat_id, "未能识别指令,请尝试 [robogo-云桌面] 或 [账单]")
def main():
# 使用 WebSocket (Long Polling) 模式,无需公网 IP
event_handler = lark.EventDispatcherHandler.builder(config.FEISHU_APP_ID, config.FEISHU_APP_SECRET) \
.register_p2_im_message_receive_v1(_on_message) \
.build()
ws_client = lark.ws.Client(config.FEISHU_APP_ID, config.FEISHU_APP_SECRET, event_handler=event_handler)
logger.info("Bot started in WebSocket mode...")
ws_client.start()
if __name__ == "__main__":
main()

View File

@ -1,7 +1,7 @@
from tests.utils.api_client import APIClient from framework.core.base_api import BaseAPI
from config.settings import Config from framework.config.settings import Config
class BillingService(APIClient): class BillingService(BaseAPI):
def __init__(self): def __init__(self):
super().__init__(Config.CLOUD_BASE_URL, Config.CLOUD_AUTH_TOKEN) super().__init__(Config.CLOUD_BASE_URL, Config.CLOUD_AUTH_TOKEN)

View File

@ -1,7 +1,7 @@
import time import time
from framework.business.cloud_desktop import CloudDesktopService from framework.business.cloud_desktop import CloudDesktopService
from config.settings import Config from framework.config.settings import Config
from tests.logger import get_logger from framework.core.logger import get_logger
from framework.models.result import StepResult from framework.models.result import StepResult
logger = get_logger("BoilerplateService") logger = get_logger("BoilerplateService")

View File

@ -1,7 +1,7 @@
import time import time
from tests.utils.api_client import APIClient from framework.core.base_api import BaseAPI
from config.settings import Config from framework.config.settings import Config
from tests.logger import get_logger from framework.core.logger import get_logger
from framework.models.result import StepResult from framework.models.result import StepResult
logger = get_logger("CloudDesktopService") logger = get_logger("CloudDesktopService")

View File

@ -1,6 +1,6 @@
import time import time
from tests.base.base_page import BasePage from framework.core.base_page import BasePage
from tests.logger import get_logger from framework.core.logger import get_logger
logger = get_logger("CloudDesktopPage") logger = get_logger("CloudDesktopPage")

View File

@ -1,5 +1,5 @@
from config.settings import Config from framework.config.settings import Config
from tests.logger import get_logger from framework.core.logger import get_logger
from framework.business.login_page import LoginPage from framework.business.login_page import LoginPage
from framework.business.file_manager_page import FileManagerPage from framework.business.file_manager_page import FileManagerPage
from framework.business.dev_machine_page import DevMachinePage from framework.business.dev_machine_page import DevMachinePage
@ -127,15 +127,14 @@ class DataManagement:
# 动态定义本次要运行的模块 # 动态定义本次要运行的模块
active_modules = [] active_modules = []
if scope == "all": if scope == "all":
active_modules = ["cloud", "dev", "mirror", "image", "openclaw"] # active_modules = ["file", "dev", "cloud", "mirror", "quant" , "3d", "image", "openclaw"]
# 暂时注释:文件系统(#folderName元素变化)、3D生成(test_data缺失)、量化工具(弹窗遮挡) active_modules = ["file", "3d","quant"]
# active_modules = ["file", "3d", "quant"]
elif scope == "smoke": elif scope == "smoke":
active_modules = ["cloud"] active_modules = ["file"] # 核心资源生命周期
elif scope == "core": elif scope == "core":
active_modules = ["cloud", "dev", "mirror", "image", "openclaw"] # 业务闭环 active_modules = ["cloud","dev", "mirror", "quant" ,"file", "image", "openclaw"] # 业务闭环
else: else:
active_modules = ["cloud"] active_modules = ["file"] # 默认兜底只跑云桌面
errors = [] errors = []

View File

@ -1,7 +1,7 @@
import time import time
from tests.utils.api_client import APIClient from framework.core.base_api import BaseAPI
from config.settings import Config from framework.config.settings import Config
from tests.logger import get_logger from framework.core.logger import get_logger
from framework.models.result import StepResult from framework.models.result import StepResult
logger = get_logger("DevMachineService") logger = get_logger("DevMachineService")

View File

@ -1,6 +1,6 @@
import time import time
from tests.base.base_page import BasePage from framework.core.base_page import BasePage
from tests.logger import get_logger from framework.core.logger import get_logger
logger = get_logger("DevMachinePage") logger = get_logger("DevMachinePage")

View File

@ -1,7 +1,7 @@
import time import time
import os import os
from tests.base.base_page import BasePage from framework.core.base_page import BasePage
from tests.logger import get_logger from framework.core.logger import get_logger
logger = get_logger("FileManagerPage") logger = get_logger("FileManagerPage")

View File

@ -2,8 +2,8 @@ import time
import os import os
import json import json
import random import random
from tests.base.base_page import BasePage from framework.core.base_page import BasePage
from tests.logger import get_logger from framework.core.logger import get_logger
logger = get_logger("ImageGenerationPage") logger = get_logger("ImageGenerationPage")

View File

@ -1,6 +1,6 @@
from framework.core.base_ui import BaseUI from framework.core.base_ui import BaseUI
from config.settings import Config from framework.config.settings import Config
from tests.logger import get_logger from framework.core.logger import get_logger
import time import time
logger = get_logger("LoginPage") logger = get_logger("LoginPage")

View File

@ -1,21 +1,25 @@
from framework.core.base_ui import BaseUI from framework.core.base_ui import BaseUI
from config.settings import Config from framework.config.settings import Config
from tests.logger import get_logger from framework.core.logger import get_logger
import time import time
logger = get_logger("LoginPage") logger = get_logger("LoginPage")
class LoginPage(BaseUI): class LoginPage(BaseUI):
USERNAME_INPUT = "input[placeholder*='account'], #form_item_userName" # --- 元素定位器 ---
PASSWORD_INPUT = "input[placeholder*='password'], #form_item_password" USERNAME_INPUT = "input[placeholder*='账号'], #account"
PASSWORD_INPUT = "input[placeholder*='密码'], #password"
LOGIN_BUTTON = "button.loginBtn" LOGIN_BUTTON = "button.loginBtn"
SUCCESS_INDICATOR = ".ant-layout-sider, .user-name"
def __init__(self, headless=False): def __init__(self, headless=False):
super().__init__(headless=headless) super().__init__(headless=headless)
def login(self, username, password): def login(self, username, password):
"""执行登录流程""" """执行登录流程"""
login_url = f"{Config.BASE_URL}/login" # 直接使用 Config.LOGIN_URL
login_url = Config.LOGIN_URL
self.navigate(login_url) self.navigate(login_url)
logger.info("等待登录页面加载...") logger.info("等待登录页面加载...")
@ -28,39 +32,22 @@ class LoginPage(BaseUI):
time.sleep(1) time.sleep(1)
self.click(self.LOGIN_BUTTON) self.click(self.LOGIN_BUTTON)
logger.info("正在实时监控重定向链路...") logger.info("登录请求已发送,等待进入系统...")
success_flag = {"done": False} try:
# 1. 强制等待关键 UI 元素出现 (证明已经跳过 SSO 到了主页)
self.page.wait_for_selector(self.SUCCESS_INDICATOR, timeout=10000)
def _check_url(frame): # 2. 二次确认 URL 是否已经离开 SSO,回到业务主域名
url = frame.url if hasattr(frame, "url") else str(frame) if "robogo-fat" in self.page.url:
if "/setting/profile" in url or "bearer=" in url or "/app-center" in url: logger.info(f"🎉 登录流程圆满成功!进入主系统 URL: {self.page.url}")
logger.info(f"⌛ 侦测到重定向轨迹: {url[:80]}...") return True
success_flag["done"] = True except Exception as e:
logger.warning(f"等待主站 UI 加载超时 (可能是 SSO 跳转慢): {e}")
self.page.on("framenavigated", _check_url) # 兜底:如果还是在 login 或 sso 页面则失败
if "/login" in self.page.url or "sso" in self.page.url:
self.page.screenshot(path="login_failed.png")
logger.error(f"❌ 登录认证失败,目前停留在: {self.page.url}")
return False
start_time = time.time() return True
while time.time() - start_time < 20:
if success_flag["done"]:
time.sleep(3)
current_url = self.page.url
if "/login" not in current_url or "/app-center" in current_url:
logger.info(f"✅ 登录验证通过!最终 URL: {current_url}")
return True
else:
logger.info("尝试补救强制跳转...")
self.page.goto(f"{Config.BASE_URL}/setting/profile", wait_until="domcontentloaded")
time.sleep(2)
if "/login" not in self.page.url:
return True
time.sleep(0.5)
# 最终兜底:如果不在登录页就算成功
current_url = self.page.url
if "/login" not in current_url:
logger.info(f"✅ 兜底判定登录成功!URL: {current_url}")
return True
self.page.screenshot(path="login_debug.png")
logger.error(f"无法确认登录成功状态。最终 URL: {current_url}")
return False

View File

@ -1,12 +1,12 @@
import random import random
from datetime import datetime from datetime import datetime
from tests.utils.api_client import APIClient from framework.core.base_api import BaseAPI
from config.settings import Config from framework.config.settings import Config
from tests.logger import get_logger from framework.core.logger import get_logger
logger = get_logger("MealReminderService") logger = get_logger("MealReminderService")
class MealReminderService(APIClient): class MealReminderService(BaseAPI):
MEAL_PERIODS = { MEAL_PERIODS = {
"breakfast": { "breakfast": {
"range": (6, 9), "emoji": "🌅", "label": "早餐", "keywords": "早餐|早点|咖啡", "range": (6, 9), "emoji": "🌅", "label": "早餐", "keywords": "早餐|早点|咖啡",

View File

@ -1,7 +1,7 @@
import time import time
from tests.base.base_page import BasePage from framework.core.base_page import BasePage
from tests.logger import get_logger from framework.core.logger import get_logger
from config.settings import Config from framework.config.settings import Config
logger = get_logger("MirrorAssetsPage") logger = get_logger("MirrorAssetsPage")

View File

@ -1,8 +1,8 @@
import time import time
import random import random
import string import string
from tests.base.base_page import BasePage from framework.core.base_page import BasePage
from tests.logger import get_logger from framework.core.logger import get_logger
logger = get_logger("OpenClawPage") logger = get_logger("OpenClawPage")

View File

@ -2,8 +2,8 @@ import time
import os import os
import random import random
import string import string
from tests.base.base_page import BasePage from framework.core.base_page import BasePage
from tests.logger import get_logger from framework.core.logger import get_logger
logger = get_logger("QuantizationPage") logger = get_logger("QuantizationPage")

View File

@ -1,6 +1,6 @@
import time import time
from tests.base.base_page import BasePage from framework.core.base_page import BasePage
from tests.logger import get_logger from framework.core.logger import get_logger
logger = get_logger("ThreeDAssetsPage") logger = get_logger("ThreeDAssetsPage")

View File

@ -2,8 +2,8 @@ import time
import os import os
import random import random
import string import string
from tests.base.base_page import BasePage from framework.core.base_page import BasePage
from tests.logger import get_logger from framework.core.logger import get_logger
logger = get_logger("ThreeDGenerationPage") logger = get_logger("ThreeDGenerationPage")

View File

@ -0,0 +1,50 @@
import random
import os
class Config:
# --- 基础配置 ---
_ENV = os.getenv("ROBOGO_ENV", "PROD").upper()
if _ENV in ["FAT"]:
BASE_URL = "https://robogo-fat.d-robotics.cc"
else:
BASE_URL = "https://robogo.d-robotics.cc"
LOGIN_URL = f"{BASE_URL}/cloud-desktop/login"
# --- 文件管理配置 ---
# 定义为静态字符串,避免导入时触发 input
FOLDER_NAME = f"UI_TEST_{random.randint(1, 1000000)}"
# --- 开发机申请配置 ---
DEV_MACHINE_NAME = f"UI_TEST_{random.randint(1, 1000000)}"
DEV_MACHINE_SKU = "sku-e154fd3a-4719-db77-3911-21c6355349ec"
SSH_PUBLIC_KEY = "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIBGp6Be0pt0Xy3Ipxm+AQTz6JQq8DAzIU6XHqD+/gzH6"
SYSTEM_DISK = "100"
# --- 登录凭证 (如果环境变量没有,则逻辑中会提示输入) ---
AUTH_ACCOUNT = os.getenv("AUTH_ACCOUNT") or os.getenv("ROBOGO_USER", "")
AUTH_PASSWORD = os.getenv("AUTH_PASSWORD") or os.getenv("ROBOGO_PWD", "")
# --- 其他框架配置 ---
TIMEOUT = 30000
INSPECTION_INTERVAL = 300
# --- 框架状态等待时长 (秒) ---
WAIT = {
'create': 60,
'stop': 30,
'delete': 30
}
# --- 云桌面 ---
CLOUD_DESKTOP_SKU = "desktop-5880gpu12g-16c32g"
CLOUD_DESKTOP_NAME = f"UI_TEST_{random.randint(1, 1000000)}"
# --- 路径配置 ---
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
TEST_DATA_DIR = os.path.join(BASE_DIR, "test_data")
TEST_FILE = os.path.join(TEST_DATA_DIR, "Fruits-15.zip")
# --- 镜像资产 ---
MIRROR_NAME = f"UI_TEST_{random.randint(1, 1000000)}"
MIRROR_SKU = "desktop-5880gpu12g-16c32g"

View File

@ -0,0 +1,63 @@
import requests
import uuid
import time
from framework.core.exceptions import TokenExpiredError, APIError
from framework.core.logger import get_logger
logger = get_logger("BaseAPI")
class BaseAPI:
def __init__(self, base_url, token=None, cookie=None):
self.base_url = base_url
self.token = token
self.cookie = cookie
self.session = requests.Session()
def get_common_headers(self, referer_path=""):
headers = {
"accept": "application/json, text/plain, */*",
"accept-language": "zh-CN,zh;q=0.9",
"authorization": self.token,
"cookie": self.cookie,
"origin": self.base_url,
"referer": f"{self.base_url}{referer_path}",
"sourceapp": "artificer",
"user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36",
"x-request-id": uuid.uuid4().hex[:21],
}
return headers
def request(self, method, endpoint, headers=None, **kwargs):
url = f"{self.base_url}{endpoint}"
# Merge default headers if none provided
if headers is None:
headers = self.get_common_headers()
try:
resp = self.session.request(method, url, headers=headers, **kwargs)
return self._check_response(resp, endpoint)
except Exception as e:
logger.error(f"Request failed: {method} {url} - {str(e)}")
raise e
def _check_response(self, resp, step_name):
if resp.status_code in (401, 403):
raise TokenExpiredError(f"[{step_name}] HTTP {resp.status_code}: 认证失败")
if resp.status_code < 200 or resp.status_code >= 300:
raise APIError(f"[{step_name}] HTTP {resp.status_code}: {resp.text}")
try:
data = resp.json()
except Exception:
raise APIError(f"[{step_name}] 非 JSON 响应: {resp.text}")
body_status = data.get("status", 0)
if body_status != 0:
msg = data.get("message", "")
if body_status in (401, 403) or "token" in msg.lower():
raise TokenExpiredError(f"[{step_name}] 认证失效: {msg}")
raise APIError(f"[{step_name}] 业务错误: {msg}")
return data

View File

@ -1,19 +1,52 @@
from framework.core.logger import get_logger
import time import time
from tests.logger import get_logger
logger = get_logger("SmartInteraction") logger = get_logger("BasePage")
class BasePage:
"""所有页面对象的基类,提供智能识别与常用操作封装"""
class SmartInteractionMixin: def __init__(self, page):
"""提供语义化点击、填写、选择等交互操作,带 JS 暴力兜底""" self.page = page
def smart_find(self, description, role=None, timeout=5000):
"""核心智能定位器:按优先级尝试语义定位"""
strategies = [
lambda: self.page.get_by_role(role, name=description, exact=False) if role else None,
lambda: self.page.get_by_text(description, exact=False),
# 新增:直接属性扫描以应对 aria-label 类按钮
lambda: self.page.locator(f'[aria-label*="{description}"]').first,
lambda: self.page.get_by_placeholder(description, exact=False),
lambda: self.page.get_by_label(description, exact=False),
lambda: self.page.get_by_title(description, exact=False)
]
for get_loc in strategies:
try:
loc = get_loc()
if loc and loc.count() > 0:
return loc.first
except:
continue
# 兜底:尝试 CSS
if any(c in description for c in [".", "#", "[", ">"]):
try:
return self.page.locator(description).first
except:
pass
raise Exception(f"❌ 无法在页面找到元素: '{description}'")
def smart_click(self, text, role=None, timeout=5000): def smart_click(self, text, role=None, timeout=5000):
"""语义化点击:带重试与可见性校验""" """语义化点击:带重试与可见性校验"""
logger.info(f"👉 [SmartClick] 尝试点击: {text}") logger.info(f"👉 [SmartClick] 尝试点击: {text}")
try: try:
el = self.smart_find(text, role=role, timeout=timeout) el = self.smart_find(text, role=role, timeout=timeout)
# 等待可见与稳定
el.wait_for(state="visible", timeout=timeout) el.wait_for(state="visible", timeout=timeout)
# 使用自带重试的点击逻辑,应对 SPA 瞬时刷新
try: try:
el.click(timeout=timeout) el.click(timeout=timeout)
except Exception as e: except Exception as e:
@ -23,6 +56,7 @@ class SmartInteractionMixin:
else: else:
raise e raise e
except Exception as e: except Exception as e:
# 暴力循环 JS 点击作为最终兜底
success = self.page.evaluate(f"""(txt) => {{ success = self.page.evaluate(f"""(txt) => {{
const target = Array.from(document.querySelectorAll('button, a, span, .p-button-label, label, input')) const target = Array.from(document.querySelectorAll('button, a, span, .p-button-label, label, input'))
.find(el => {{ .find(el => {{
@ -42,7 +76,7 @@ class SmartInteractionMixin:
raise e raise e
def smart_click_any(self, texts, role=None, timeout=5000): def smart_click_any(self, texts, role=None, timeout=5000):
"""按多个候选文案点击,兼容新旧页面元素文案""" """按多个候选文案点击,兼容新旧页面元素文案。"""
last_error = None last_error = None
for text in texts: for text in texts:
try: try:
@ -53,8 +87,32 @@ class SmartInteractionMixin:
logger.info(f" 候选元素未命中 [{text}]: {e}") logger.info(f" 候选元素未命中 [{text}]: {e}")
raise last_error or Exception(f"❌ 无法点击任一候选元素: {texts}") raise last_error or Exception(f"❌ 无法点击任一候选元素: {texts}")
def goto_route(self, route):
"""在当前登录域名下跳转到指定前端路由。"""
from urllib.parse import urlsplit
current = self.page.url or ""
parsed = urlsplit(current)
if parsed.scheme and parsed.netloc:
base = f"{parsed.scheme}://{parsed.netloc}"
else:
from framework.config.settings import Config
base = Config.BASE_URL
if not route.startswith("/"):
route = f"/{route}"
self.page.goto(f"{base}{route}", wait_until="domcontentloaded")
def visible_dialog(self, text=None):
"""返回当前可见的最上层 PrimeVue/Dialog 容器。"""
selector = ".p-dialog, [role='dialog']"
loc = self.page.locator(selector)
if text:
loc = loc.filter(has_text=text)
return loc.last
def click_row_action(self, row_text, action_label, icon_classes=None, timeout=5000): def click_row_action(self, row_text, action_label, icon_classes=None, timeout=5000):
"""点击表格/卡片行内操作,兼容文本按钮、aria、tooltip 和图标按钮""" """点击表格/卡片行内操作,兼容文本按钮、aria、tooltip 和图标按钮。"""
icon_classes = icon_classes or [] icon_classes = icon_classes or []
logger.info(f"👉 [RowAction] 在 [{row_text}] 容器内点击 [{action_label}]") logger.info(f"👉 [RowAction] 在 [{row_text}] 容器内点击 [{action_label}]")
@ -111,7 +169,7 @@ class SmartInteractionMixin:
if loc.count() and loc.is_visible(timeout=500): if loc.count() and loc.is_visible(timeout=500):
loc.click() loc.click()
return True return True
except Exception: except:
continue continue
raise Exception(f"❌ 未找到 [{row_text}] 的行内操作 [{action_label}]") raise Exception(f"❌ 未找到 [{row_text}] 的行内操作 [{action_label}]")
@ -119,18 +177,22 @@ class SmartInteractionMixin:
"""语义化输入:支持 Vue/React 的深度绑定注入""" """语义化输入:支持 Vue/React 的深度绑定注入"""
logger.info(f"⌨️ [SmartFill] 在 [{label}] 填写: {value}") logger.info(f"⌨️ [SmartFill] 在 [{label}] 填写: {value}")
try: try:
# 1. 尝试直接命中 (Label/Placeholder等原生属性)
el = self.smart_find(label, timeout=timeout) el = self.smart_find(label, timeout=timeout)
el.wait_for(state="visible", timeout=timeout) el.wait_for(state="visible", timeout=timeout)
el.fill(value, timeout=timeout) el.fill(value, timeout=timeout)
except Exception as first_err: except Exception as first_err:
try: try:
# 2. 邻近注入方案:借助 JS 寻找关联输入框,并使用 Playwright 原生 fill 保障前端框架双向绑定
logger.info(f"🔍 [SmartFill] 常规规则未命中,正在执行深度邻近探测 [{label}]...") logger.info(f"🔍 [SmartFill] 常规规则未命中,正在执行深度邻近探测 [{label}]...")
success = self.page.evaluate(f"""(lbl) => {{ success = self.page.evaluate(f"""(lbl) => {{
document.querySelectorAll('[data-smart-target]').forEach(e => e.removeAttribute('data-smart-target')); document.querySelectorAll('[data-smart-target]').forEach(e => e.removeAttribute('data-smart-target'));
// 1. 过滤:必须是有高度/宽度的真实可见节点
const allNodes = Array.from(document.querySelectorAll('label, span, div, p, legend')) const allNodes = Array.from(document.querySelectorAll('label, span, div, p, legend'))
.filter(el => el.offsetWidth > 0 && el.offsetHeight > 0 && el.innerText && el.innerText.includes(lbl)); .filter(el => el.offsetWidth > 0 && el.offsetHeight > 0 && el.innerText && el.innerText.includes(lbl));
// 2. 最深层过滤
const tags = allNodes.filter(el => {{ const tags = allNodes.filter(el => {{
return !Array.from(el.children).some(child => child.offsetWidth > 0 && child.innerText && child.innerText.includes(lbl)); return !Array.from(el.children).some(child => child.offsetWidth > 0 && child.innerText && child.innerText.includes(lbl));
}}); }});
@ -159,7 +221,7 @@ class SmartInteractionMixin:
logger.error(f"⚠️ [SmartFill] JS注入或执行时发生错误: {second_err}") logger.error(f"⚠️ [SmartFill] JS注入或执行时发生错误: {second_err}")
raise second_err raise second_err
def smart_delete(self, text, role=None, timeout=5000): def smart_delete(self,text,role=None,timeout=5000):
logger.info(f"👉 [SmartDelete] 尝试删除: {text}") logger.info(f"👉 [SmartDelete] 尝试删除: {text}")
try: try:
el = self.smart_find(text, role=role, timeout=timeout) el = self.smart_find(text, role=role, timeout=timeout)
@ -173,6 +235,7 @@ class SmartInteractionMixin:
"""智能下拉框选择 (适配 PrimeVue)""" """智能下拉框选择 (适配 PrimeVue)"""
logger.info(f"📋 [SmartSelect] 在 [{label}] 下拉框寻找目标: {value}") logger.info(f"📋 [SmartSelect] 在 [{label}] 下拉框寻找目标: {value}")
# 1. 寻找并打开下拉框
opened = self.page.evaluate("""([lbl, val]) => { opened = self.page.evaluate("""([lbl, val]) => {
const root = document.querySelector('.p-dialog') || document.querySelector('[role="dialog"]') || document; const root = document.querySelector('.p-dialog') || document.querySelector('[role="dialog"]') || document;
const elements = Array.from(root.querySelectorAll('label, span, div')); const elements = Array.from(root.querySelectorAll('label, span, div'));
@ -186,12 +249,14 @@ class SmartInteractionMixin:
let container = targetLabel; let container = targetLabel;
for (let i = 0; i < 8; i++) { for (let i = 0; i < 8; i++) {
if (!container) break; if (!container) break;
// 查找下拉框容器
const dd = container.querySelector('.p-select, .p-dropdown, [data-pc-name="select"], [data-pc-name="dropdown"]'); const dd = container.querySelector('.p-select, .p-dropdown, [data-pc-name="select"], [data-pc-name="dropdown"]');
if (dd && dd.offsetWidth > 0) { if (dd && dd.offsetWidth > 0) {
dd.scrollIntoView({block: 'center'}); dd.scrollIntoView({block: 'center'});
dd.click(); dd.click();
return 'OPENED'; return 'OPENED';
} }
// 检查兄弟元素
if (container.parentElement) { if (container.parentElement) {
const sibling = container.parentElement.querySelector('.p-select, .p-dropdown, [data-pc-name="select"]'); const sibling = container.parentElement.querySelector('.p-select, .p-dropdown, [data-pc-name="select"]');
if (sibling && sibling.offsetWidth > 0) { if (sibling && sibling.offsetWidth > 0) {
@ -211,7 +276,9 @@ class SmartInteractionMixin:
time.sleep(1) time.sleep(1)
# 2. 尝试多种定位器点击选项
try: try:
# 优先精准文本
selectors = [ selectors = [
f"li[role='option']:has-text('{value}')", f"li[role='option']:has-text('{value}')",
f".p-select-option:has-text('{value}')", f".p-select-option:has-text('{value}')",
@ -223,9 +290,10 @@ class SmartInteractionMixin:
loc.click() loc.click()
logger.info(f"✅ [SmartSelect] 成功通过选择器选中: {value}") logger.info(f"✅ [SmartSelect] 成功通过选择器选中: {value}")
return True return True
except Exception: except:
pass pass
# 3. JS 暴力匹配并点击
clicked = self.page.evaluate("""(val) => { clicked = self.page.evaluate("""(val) => {
const options = Array.from(document.querySelectorAll('li[role="option"], .p-select-option, .p-dropdown-item')); const options = Array.from(document.querySelectorAll('li[role="option"], .p-select-option, .p-dropdown-item'));
const target = options.find(opt => opt.offsetWidth > 0 && opt.innerText.includes(val)); const target = options.find(opt => opt.offsetWidth > 0 && opt.innerText.includes(val));

View File

@ -2,7 +2,7 @@
UI 自动化基类占位 (推荐使用 Playwright) UI 自动化基类占位 (推荐使用 Playwright)
""" """
from playwright.sync_api import sync_playwright from playwright.sync_api import sync_playwright
from tests.logger import get_logger from framework.core.logger import get_logger
import time import time
logger = get_logger("BaseUI") logger = get_logger("BaseUI")

21
framework/core/logger.py Normal file
View File

@ -0,0 +1,21 @@
import logging
import os
def get_logger(name: str):
logger = logging.getLogger(name)
if not logger.handlers:
logger.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s [%(name)s] [%(levelname)s] %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
# 控制台输出
ch = logging.StreamHandler()
ch.setFormatter(formatter)
logger.addHandler(ch)
# 文件输出
log_file = os.path.join(os.getcwd(), 'automation.log')
fh = logging.FileHandler(log_file)
fh.setFormatter(formatter)
logger.addHandler(fh)
return logger

View File

@ -1,7 +1,7 @@
# framework/scripts/compute_resource_scenario.py # framework/scripts/compute_resource_scenario.py
import time import time
from config.settings import Config from framework.config.settings import Config
from tests.logger import get_logger from framework.core.logger import get_logger
logger = get_logger("ComputeResourceScenario") logger = get_logger("ComputeResourceScenario")

View File

@ -1,8 +1,8 @@
# framework/scripts/desktop_lifecycle.py # framework/scripts/desktop_lifecycle.py
"""云桌面 UI 全生命周期巡检脚本""" """云桌面 UI 全生命周期巡检脚本"""
import time import time
from config.settings import Config from framework.config.settings import Config
from tests.logger import get_logger from framework.core.logger import get_logger
logger = get_logger("DesktopLifecycleScenario") logger = get_logger("DesktopLifecycleScenario")

View File

@ -2,7 +2,7 @@
import os import os
import time import time
import random import random
from tests.logger import get_logger from framework.core.logger import get_logger
logger = get_logger("FileSystemScenario") logger = get_logger("FileSystemScenario")
@ -42,7 +42,7 @@ def run_full_file_lifecycle(fm, folder_name):
fm.enter_folder(folder_name) fm.enter_folder(folder_name)
# 2. 收集 test_data 目录下所有文件 # 2. 收集 test_data 目录下所有文件
from config.settings import Config from framework.config.settings import Config
test_data_dir = Config.TEST_DATA_DIR test_data_dir = Config.TEST_DATA_DIR
if not os.path.isdir(test_data_dir): if not os.path.isdir(test_data_dir):

View File

@ -1,6 +1,6 @@
import os import os
import time import time
from tests.logger import get_logger from framework.core.logger import get_logger
logger = get_logger("ImageGenerationScenario") logger = get_logger("ImageGenerationScenario")

View File

@ -1,6 +1,6 @@
import time import time
from config.settings import Config from framework.config.settings import Config
from tests.logger import get_logger from framework.core.logger import get_logger
from framework.business.cloud_desktop_page import CloudDesktopPage from framework.business.cloud_desktop_page import CloudDesktopPage
logger = get_logger("MirrorAssetsScenario") logger = get_logger("MirrorAssetsScenario")

View File

@ -1,6 +1,6 @@
import time import time
import random import random
from tests.logger import get_logger from framework.core.logger import get_logger
logger = get_logger("MonkeyTester") logger = get_logger("MonkeyTester")

View File

@ -1,4 +1,4 @@
from tests.logger import get_logger from framework.core.logger import get_logger
logger = get_logger("OpenClawScenario") logger = get_logger("OpenClawScenario")

View File

@ -1,7 +1,7 @@
import time import time
import random import random
import string import string
from tests.logger import get_logger from framework.core.logger import get_logger
from framework.business.quantization_page import QuantizationPage from framework.business.quantization_page import QuantizationPage
logger = get_logger("QuantizationScenario") logger = get_logger("QuantizationScenario")

View File

@ -1,23 +0,0 @@
"""
AutoFlow - Robogo Full-Chain UI Inspection Entry Point
"""
import os
import sys
PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
sys.path.insert(0, PROJECT_ROOT)
from framework.business.data_management import DataManagement
def main():
runner = DataManagement(
headless=os.environ.get("HEADLESS", "true").lower() == "true"
)
account = os.environ.get("AUTH_ACCOUNT") or os.environ.get("ROBOGO_USER", "")
password = os.environ.get("AUTH_PASSWORD") or os.environ.get("ROBOGO_PWD", "")
runner.run(account, password)
if __name__ == "__main__":
main()

View File

@ -1,15 +0,0 @@
"""
AutoFlow - Data Loop Business Pipeline Validation Entry Point
"""
import os
import sys
def main():
print("[Data Loop] Starting data loop inspection...")
print("[Data Loop] Note: full implementation requires dataloop/data-loop-automation directory.")
print("[Data Loop] Inspection completed.")
if __name__ == "__main__":
main()

View File

@ -1,5 +1,5 @@
import time import time
from tests.logger import get_logger from framework.core.logger import get_logger
logger = get_logger("ThreeDAssetsScenario") logger = get_logger("ThreeDAssetsScenario")

View File

@ -1,8 +1,8 @@
import os import os
import random import random
import time import time
from tests.logger import get_logger from framework.core.logger import get_logger
from config.settings import Config from framework.config.settings import Config
logger = get_logger("ThreeDGenerationScenario") logger = get_logger("ThreeDGenerationScenario")

22
frontend/eslint.config.js Normal file
View File

@ -0,0 +1,22 @@
import js from '@eslint/js'
import globals from 'globals'
import reactHooks from 'eslint-plugin-react-hooks'
import reactRefresh from 'eslint-plugin-react-refresh'
import tseslint from 'typescript-eslint'
import { defineConfig, globalIgnores } from 'eslint/config'
export default defineConfig([
globalIgnores(['dist']),
{
files: ['**/*.{ts,tsx}'],
extends: [
js.configs.recommended,
tseslint.configs.recommended,
reactHooks.configs.flat.recommended,
reactRefresh.configs.vite,
],
languageOptions: {
globals: globals.browser,
},
},
])

View File

@ -3,7 +3,7 @@
<head> <head>
<meta charset="UTF-8" /> <meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>TestAgent | 智能测试平台</title> <title>AutoFlow | 统一自动化测试平台</title>
</head> </head>
<body> <body>
<div id="root"></div> <div id="root"></div>

2302
frontend/pnpm-lock.yaml generated Normal file

File diff suppressed because it is too large Load Diff

View File

@ -1,2 +0,0 @@
allowBuilds:
esbuild: true

File diff suppressed because one or more lines are too long

After

Width:  |  Height:  |  Size: 9.3 KiB

24
frontend/public/icons.svg Normal file
View File

@ -0,0 +1,24 @@
<svg xmlns="http://www.w3.org/2000/svg">
<symbol id="bluesky-icon" viewBox="0 0 16 17">
<g clip-path="url(#bluesky-clip)"><path fill="#08060d" d="M7.75 7.735c-.693-1.348-2.58-3.86-4.334-5.097-1.68-1.187-2.32-.981-2.74-.79C.188 2.065.1 2.812.1 3.251s.241 3.602.398 4.13c.52 1.744 2.367 2.333 4.07 2.145-2.495.37-4.71 1.278-1.805 4.512 3.196 3.309 4.38-.71 4.987-2.746.608 2.036 1.307 5.91 4.93 2.746 2.72-2.746.747-4.143-1.747-4.512 1.702.189 3.55-.4 4.07-2.145.156-.528.397-3.691.397-4.13s-.088-1.186-.575-1.406c-.42-.19-1.06-.395-2.741.79-1.755 1.24-3.64 3.752-4.334 5.099"/></g>
<defs><clipPath id="bluesky-clip"><path fill="#fff" d="M.1.85h15.3v15.3H.1z"/></clipPath></defs>
</symbol>
<symbol id="discord-icon" viewBox="0 0 20 19">
<path fill="#08060d" d="M16.224 3.768a14.5 14.5 0 0 0-3.67-1.153c-.158.286-.343.67-.47.976a13.5 13.5 0 0 0-4.067 0c-.128-.306-.317-.69-.476-.976A14.4 14.4 0 0 0 3.868 3.77C1.546 7.28.916 10.703 1.231 14.077a14.7 14.7 0 0 0 4.5 2.306q.545-.748.965-1.587a9.5 9.5 0 0 1-1.518-.74q.191-.14.372-.293c2.927 1.369 6.107 1.369 8.999 0q.183.152.372.294-.723.437-1.52.74.418.838.963 1.588a14.6 14.6 0 0 0 4.504-2.308c.37-3.911-.63-7.302-2.644-10.309m-9.13 8.234c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.894 0 1.614.82 1.599 1.82.001 1-.705 1.82-1.6 1.82m5.91 0c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.893 0 1.614.82 1.599 1.82 0 1-.706 1.82-1.6 1.82"/>
</symbol>
<symbol id="documentation-icon" viewBox="0 0 21 20">
<path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="m15.5 13.333 1.533 1.322c.645.555.967.833.967 1.178s-.322.623-.967 1.179L15.5 18.333m-3.333-5-1.534 1.322c-.644.555-.966.833-.966 1.178s.322.623.966 1.179l1.534 1.321"/>
<path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M17.167 10.836v-4.32c0-1.41 0-2.117-.224-2.68-.359-.906-1.118-1.621-2.08-1.96-.599-.21-1.349-.21-2.848-.21-2.623 0-3.935 0-4.983.369-1.684.591-3.013 1.842-3.641 3.428C3 6.449 3 7.684 3 10.154v2.122c0 2.558 0 3.838.706 4.726q.306.383.713.671c.76.536 1.79.64 3.581.66"/>
<path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M3 10a2.78 2.78 0 0 1 2.778-2.778c.555 0 1.209.097 1.748-.047.48-.129.854-.503.982-.982.145-.54.048-1.194.048-1.749a2.78 2.78 0 0 1 2.777-2.777"/>
</symbol>
<symbol id="github-icon" viewBox="0 0 19 19">
<path fill="#08060d" fill-rule="evenodd" d="M9.356 1.85C5.05 1.85 1.57 5.356 1.57 9.694a7.84 7.84 0 0 0 5.324 7.44c.387.079.528-.168.528-.376 0-.182-.013-.805-.013-1.454-2.165.467-2.616-.935-2.616-.935-.349-.91-.864-1.143-.864-1.143-.71-.48.051-.48.051-.48.787.051 1.2.805 1.2.805.695 1.194 1.817.857 2.268.649.064-.507.27-.857.49-1.052-1.728-.182-3.545-.857-3.545-3.87 0-.857.31-1.558.8-2.104-.078-.195-.349-1 .077-2.078 0 0 .657-.208 2.14.805a7.5 7.5 0 0 1 1.946-.26c.657 0 1.328.092 1.946.26 1.483-1.013 2.14-.805 2.14-.805.426 1.078.155 1.883.078 2.078.502.546.799 1.247.799 2.104 0 3.013-1.818 3.675-3.558 3.87.284.247.528.714.528 1.454 0 1.052-.012 1.896-.012 2.156 0 .208.142.455.528.377a7.84 7.84 0 0 0 5.324-7.441c.013-4.338-3.48-7.844-7.773-7.844" clip-rule="evenodd"/>
</symbol>
<symbol id="social-icon" viewBox="0 0 20 20">
<path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M12.5 6.667a4.167 4.167 0 1 0-8.334 0 4.167 4.167 0 0 0 8.334 0"/>
<path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M2.5 16.667a5.833 5.833 0 0 1 8.75-5.053m3.837.474.513 1.035c.07.144.257.282.414.309l.93.155c.596.1.736.536.307.965l-.723.73a.64.64 0 0 0-.152.531l.207.903c.164.715-.213.991-.84.618l-.872-.52a.63.63 0 0 0-.577 0l-.872.52c-.624.373-1.003.094-.84-.618l.207-.903a.64.64 0 0 0-.152-.532l-.723-.729c-.426-.43-.289-.864.306-.964l.93-.156a.64.64 0 0 0 .412-.31l.513-1.034c.28-.562.735-.562 1.012 0"/>
</symbol>
<symbol id="x-icon" viewBox="0 0 19 19">
<path fill="#08060d" fill-rule="evenodd" d="M1.893 1.98c.052.072 1.245 1.769 2.653 3.77l2.892 4.114c.183.261.333.48.333.486s-.068.089-.152.183l-.522.593-.765.867-3.597 4.087c-.375.426-.734.834-.798.905a1 1 0 0 0-.118.148c0 .01.236.017.664.017h.663l.729-.83c.4-.457.796-.906.879-.999a692 692 0 0 0 1.794-2.038c.034-.037.301-.34.594-.675l.551-.624.345-.392a7 7 0 0 1 .34-.374c.006 0 .93 1.306 2.052 2.903l2.084 2.965.045.063h2.275c1.87 0 2.273-.003 2.266-.021-.008-.02-1.098-1.572-3.894-5.547-2.013-2.862-2.28-3.246-2.273-3.266.008-.019.282-.332 2.085-2.38l2-2.274 1.567-1.782c.022-.028-.016-.03-.65-.03h-.674l-.3.342a871 871 0 0 1-1.782 2.025c-.067.075-.405.458-.75.852a100 100 0 0 1-.803.91c-.148.172-.299.344-.99 1.127-.304.343-.32.358-.345.327-.015-.019-.904-1.282-1.976-2.808L6.365 1.85H1.8zm1.782.91 8.078 11.294c.772 1.08 1.413 1.973 1.425 1.984.016.017.241.02 1.05.017l1.03-.004-2.694-3.766L7.796 5.75 5.722 2.852l-1.039-.004-1.039-.004z" clip-rule="evenodd"/>
</symbol>
</svg>

After

Width:  |  Height:  |  Size: 4.9 KiB

View File

@ -1 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" viewBox="0 0 32 32"><rect width="32" height="32" rx="6" fill="#6c72ff"/><text x="16" y="22" text-anchor="middle" fill="white" font-size="18" font-family="sans-serif" font-weight="bold">TA</text></svg>

Before

Width:  |  Height:  |  Size: 263 B

View File

@ -1,32 +1,31 @@
import { BrowserRouter, Routes, Route, Navigate } from 'react-router-dom' import { BrowserRouter, Routes, Route, Navigate } from 'react-router-dom';
import { ThemeProvider } from './context/ThemeContext' import { ThemeProvider } from './context/ThemeContext';
import ErrorBoundary from './components/ErrorBoundary' import Layout from './components/layout/Layout';
import Layout from './components/layout/Layout' import DCloudDashboard from './components/dashboard/DCloudDashboard';
import Dashboard from './components/dashboard/Dashboard' import RobogoDashboard from './components/dashboard/RobogoDashboard';
import ReposView from './components/repos/ReposView' import TestModuleView from './components/test/TestModuleView';
import TasksView from './components/tasks/TasksView' import E2ETestView from './components/test/E2ETestView';
import ReportsView from './components/reports/ReportsView' import TasksView from './components/tasks/TasksView';
import ExistingTestsView from './components/existing/ExistingTestsView' import ReportsView from './components/reports/ReportsView';
import './index.css' import './index.css';
export default function App() { export default function App() {
return ( return (
<ErrorBoundary> <ThemeProvider>
<ThemeProvider> <BrowserRouter>
<BrowserRouter> <Routes>
<Routes> <Route element={<Layout />}>
<Route element={<Layout />}> <Route index element={<Navigate to="/dcloud" replace />} />
<Route index element={<Dashboard />} /> <Route path="dcloud" element={<DCloudDashboard />} />
<Route path="dashboard" element={<Dashboard />} /> <Route path="dcloud/e2e" element={<E2ETestView />} />
<Route path="repos" element={<ReposView />} /> <Route path="dcloud/:module" element={<TestModuleView />} />
<Route path="tasks" element={<TasksView />} /> <Route path="robogo" element={<RobogoDashboard />} />
<Route path="reports" element={<ReportsView />} /> <Route path="robogo/tasks" element={<TasksView />} />
<Route path="existing" element={<ExistingTestsView />} /> <Route path="robogo/reports" element={<ReportsView />} />
<Route path="*" element={<Navigate to="/" replace />} /> <Route path="*" element={<Navigate to="/dcloud" replace />} />
</Route> </Route>
</Routes> </Routes>
</BrowserRouter> </BrowserRouter>
</ThemeProvider> </ThemeProvider>
</ErrorBoundary> );
)
} }

View File

@ -0,0 +1,65 @@
import { Clock, CheckCircle2, XCircle, Circle } from 'lucide-react';
interface ActivityEntry {
id: string;
module: string;
status: 'passed' | 'failed' | 'running';
duration: number;
timestamp: string;
}
interface ActivityTableProps {
items: ActivityEntry[];
}
export default function ActivityTable({ items }: ActivityTableProps) {
if (items.length === 0) {
return (
<div className="bg-card rounded-xl border border-border p-5 h-full flex flex-col items-center justify-center">
<Clock className="w-8 h-8 text-slate-200 mb-2" />
<p className="text-sm text-text-secondary">无最近活动</p>
<p className="text-xs text-slate-400 mt-1">运行测试后记录将显示在此处</p>
</div>
);
}
return (
<div className="bg-card rounded-xl border border-border p-5 h-full">
<div className="flex items-center justify-between mb-4">
<h4 className="text-sm font-semibold text-text-primary">最近执行记录</h4>
<span className="text-[11px] text-text-secondary">{items.length} 条记录</span>
</div>
<div className="space-y-1.5">
{items.map((item) => (
<div
key={item.id}
className="flex items-center justify-between py-2 px-2 rounded-lg hover:bg-slate-50 transition-colors"
>
<div className="flex items-center gap-3">
{item.status === 'passed' ? (
<CheckCircle2 className="w-4 h-4 text-success" />
) : item.status === 'failed' ? (
<XCircle className="w-4 h-4 text-danger" />
) : (
<Circle className="w-4 h-4 text-blue-500 animate-pulse" />
)}
<div>
<p className="text-sm font-medium text-text-primary">{item.module}</p>
<p className="text-[11px] text-text-secondary">{item.timestamp}</p>
</div>
</div>
<div className="text-right">
<p className={`text-sm font-mono font-semibold ${
item.status === 'passed' ? 'text-success' :
item.status === 'failed' ? 'text-danger' : 'text-blue-500'
}`}>
{item.status === 'passed' ? '通过' : item.status === 'failed' ? '失败' : '运行中'}
</p>
<p className="text-[11px] text-slate-400">{item.duration}s</p>
</div>
</div>
))}
</div>
</div>
);
}

View File

@ -1,48 +0,0 @@
import { Component, ReactNode } from 'react'
interface Props {
children: ReactNode
}
interface State {
hasError: boolean
error: Error | null
}
export default class ErrorBoundary extends Component<Props, State> {
constructor(props: Props) {
super(props)
this.state = { hasError: false, error: null }
}
static getDerivedStateFromError(error: Error): State {
return { hasError: true, error }
}
componentDidCatch(error: Error, errorInfo: React.ErrorInfo) {
console.error('ErrorBoundary caught:', error, errorInfo)
}
render() {
if (this.state.hasError) {
return (
<div className="flex items-center justify-center min-h-screen bg-[rgb(var(--color-page))]">
<div className="text-center max-w-md p-8">
<div className="text-5xl mb-4">⚠️</div>
<h2 className="text-lg font-medium text-[rgb(var(--color-text-primary))] mb-2">页面出错了</h2>
<p className="text-sm text-[rgb(var(--color-text-secondary))] mb-4">
{this.state.error?.message || '发生了未知错误'}
</p>
<button
onClick={() => window.location.reload()}
className="px-4 py-2 rounded-lg text-sm font-medium bg-[rgb(var(--color-accent))] text-white hover:bg-[rgb(var(--color-accent-hover))] transition-colors"
>
刷新页面
</button>
</div>
</div>
)
}
return this.props.children
}
}

View File

@ -0,0 +1,62 @@
import { useRef, useEffect } from 'react';
export interface LogEntry {
id: number;
msg: string;
cls: string;
timestamp: string;
}
interface LogPanelProps {
logs: LogEntry[];
status: string;
onClear: () => void;
}
export default function LogPanel({ logs, status, onClear }: LogPanelProps) {
const panelRef = useRef<HTMLPreElement>(null);
useEffect(() => {
if (panelRef.current) {
panelRef.current.scrollTop = panelRef.current.scrollHeight;
}
}, [logs]);
return (
<div className="mt-6 bg-gray-900 rounded-xl overflow-hidden">
<div className="flex items-center justify-between px-5 py-3 bg-gray-800 border-b border-gray-700">
<div className="flex items-center gap-2 text-gray-300 text-sm">
<svg className="w-4 h-4" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
<polyline points="4 17 10 11 4 5" />
<line x1="12" y1="19" x2="20" y2="19" />
</svg>
<span>测试日志</span>
</div>
<div className="flex items-center gap-3">
<span className={`text-xs ${status === '就绪' ? 'text-gray-500' : 'text-blue-500'}`}>{status}</span>
<button onClick={onClear} className="text-gray-500 hover:text-gray-300 text-xs cursor-pointer">
<svg className="w-3.5 h-3.5 inline mr-0.5" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
<polyline points="3 6 5 6 21 6" />
<path d="M19 6v14a2 2 0 01-2 2H7a2 2 0 01-2-2V6m3 0V4a2 2 0 012-2h4a2 2 0 012 2v2" />
</svg>
清空
</button>
</div>
</div>
<pre
ref={panelRef}
className="p-5 text-sm text-green-400 font-mono leading-relaxed overflow-auto max-h-80 min-h-[200px] whitespace-pre-wrap"
>
{logs.length === 0 ? (
<span className="text-gray-500">等待测试触发...</span>
) : (
logs.map((entry) => (
<div key={entry.id} className={entry.cls || undefined}>
{entry.msg}
</div>
))
)}
</pre>
</div>
);
}

View File

@ -0,0 +1,80 @@
import { useRef, useEffect } from 'react';
import { Terminal, Trash2 } from 'lucide-react';
export interface LogEntry {
id: number;
msg: string;
cls: string;
timestamp: string;
}
interface LogPanelProps {
logs: LogEntry[];
status: string;
onClear: () => void;
}
export default function LogTerminal({ logs, status, onClear }: LogPanelProps) {
const panelRef = useRef<HTMLDivElement>(null);
useEffect(() => {
if (panelRef.current) {
panelRef.current.scrollTop = panelRef.current.scrollHeight;
}
}, [logs]);
const getDotColor = () => {
if (status === '就绪') return 'bg-slate-400';
return 'bg-blue-500 animate-pulse';
};
return (
<div className="mt-6 rounded-xl border border-slate-800 bg-[#0a0f1a] overflow-hidden shadow-lg">
<div className="flex items-center justify-between px-4 py-2.5 bg-[#111827] border-b border-slate-800">
<div className="flex items-center gap-2.5">
<div className="flex gap-1.5">
<div className="w-3 h-3 rounded-full bg-red-500/80" />
<div className="w-3 h-3 rounded-full bg-amber-500/80" />
<div className="w-3 h-3 rounded-full bg-green-500/80" />
</div>
<div className="h-4 w-px bg-slate-700" />
<Terminal className="w-3.5 h-3.5 text-slate-500" />
<span className="text-xs text-slate-400 font-mono tracking-wider">TERMINAL</span>
</div>
<div className="flex items-center gap-3">
<div className="flex items-center gap-1.5">
<div className={`w-2 h-2 rounded-full ${getDotColor()}`} />
<span className="text-[11px] text-slate-500 font-mono">{status}</span>
</div>
<button
onClick={onClear}
className="flex items-center gap-1 text-slate-600 hover:text-slate-300 text-[11px] transition-colors cursor-pointer"
>
<Trash2 className="w-3 h-3" />
清空
</button>
</div>
</div>
<div
ref={panelRef}
className="p-4 text-[13px] font-mono leading-relaxed overflow-auto h-72 whitespace-pre-wrap"
style={{ fontFamily: "'JetBrains Mono', 'Fira Code', 'Cascadia Code', monospace" }}
>
{logs.length === 0 ? (
<div className="text-slate-600 flex items-center gap-2">
<span className="text-slate-700">$</span>
<span className="animate-pulse">等待测试触发...</span>
<span className="inline-block w-2 h-4 bg-slate-700 animate-pulse ml-0.5" />
</div>
) : (
logs.map((entry) => (
<div key={entry.id} className={entry.cls || 'text-slate-400'}>
<span className="text-slate-700 select-none mr-2">›</span>
{entry.msg}
</div>
))
)}
</div>
</div>
);
}

View File

@ -0,0 +1,41 @@
import { Moon, Globe } from 'lucide-react';
const NAV_ITEMS = [
{ label: '工作台', hasDropdown: true },
{ label: '云端实验室', hasDropdown: true },
{ label: '数据空间', hasDropdown: false },
{ label: '监控看板', hasDropdown: false },
{ label: '镜像中心', hasDropdown: false },
];
export default function Navbar() {
return (
<header className="flex items-center justify-between px-8 py-5">
<div className="flex items-center gap-10">
<div className="w-10 h-10 relative">
<div className="absolute left-0 top-1 w-3 h-3 rounded-full bg-brandOrange" />
<div className="absolute left-2 top-0 w-6 h-8 border-2 border-black rounded-l-lg" />
</div>
<nav className="flex gap-8 text-[17px]">
{NAV_ITEMS.map((item) => (
<div key={item.label} className="flex items-center gap-1 cursor-pointer hover:text-brandOrange transition-colors">
{item.label}
{item.hasDropdown && (
<svg className="w-3 h-3 mt-1" viewBox="0 0 12 12" fill="none">
<path d="M3 4.5L6 7.5L9 4.5" stroke="currentColor" strokeWidth="1.5" />
</svg>
)}
</div>
))}
</nav>
</div>
<div className="flex items-center gap-6 text-lg">
<Moon className="w-5 h-5 cursor-pointer hover:text-brandOrange transition-colors" />
<Globe className="w-5 h-5 cursor-pointer hover:text-brandOrange transition-colors" />
<div className="w-10 h-10 rounded-full bg-[#f9e2cb] flex items-center justify-center font-medium cursor-pointer text-sm">
A
</div>
</div>
</header>
);
}

View File

@ -0,0 +1,33 @@
import { Sparkles, ArrowRight } from 'lucide-react';
const NEWS = [
{ text: '全新「镜像中心」上线,支持 Docker 镜像管理与多版本控制', date: '2026-06-01' },
{ text: '自动化测试面板升级,新增全量回归测试与实时日志追踪', date: '2026-05-28' },
{ text: '视觉感知工作台性能优化,推理速度提升 40%', date: '2026-05-20' },
];
export default function NewsSection() {
return (
<div className="bg-card rounded-xl border border-border p-5">
<div className="flex items-center justify-between mb-4">
<div className="flex items-center gap-2">
<div className="w-8 h-8 rounded-lg bg-amber-100 flex items-center justify-center">
<Sparkles className="w-4 h-4 text-amber-600" />
</div>
<h3 className="font-semibold text-sm text-text-primary">平台动态</h3>
</div>
<span className="text-xs text-text-secondary hover:text-primary cursor-pointer flex items-center gap-1">
查看全部 <ArrowRight className="w-3 h-3" />
</span>
</div>
<div className="space-y-2.5">
{NEWS.map((item, i) => (
<div key={i} className="flex items-center justify-between py-1.5 border-b border-border/50 last:border-0">
<span className="text-sm text-text-secondary">{item.text}</span>
<span className="text-[11px] text-slate-400 shrink-0 ml-4">{item.date}</span>
</div>
))}
</div>
</div>
);
}

View File

@ -0,0 +1,110 @@
import { useState } from 'react';
import {
LayoutDashboard,
Database,
BarChart3,
Box,
Monitor,
Code2,
Cpu,
Image,
Layers,
ChevronLeft,
ChevronRight,
} from 'lucide-react';
interface NavItem {
label: string;
icon: React.ElementType;
id: string;
badge?: number;
}
const NAV_ITEMS: NavItem[] = [
{ label: 'Dashboard', icon: LayoutDashboard, id: 'dashboard' },
{ label: '工作台', icon: Box, id: 'workbench', badge: 3 },
{ label: '数据空间', icon: Database, id: 'data_space' },
{ label: '数据集', icon: Layers, id: 'data_set' },
{ label: '监控看板', icon: BarChart3, id: 'monitor' },
{ label: '图像管理', icon: Image, id: 'image_manage' },
{ label: '镜像中心', icon: Image, id: 'mirror_center' },
{ label: '模型工作台', icon: Cpu, id: 'model_workshop' },
{ label: '云端桌面', icon: Monitor, id: 'cloud_desktop' },
{ label: '开发机', icon: Code2, id: 'dev_machine' },
];
interface SidebarProps {
activeId: string;
onSelect: (id: string) => void;
}
export default function Sidebar({ activeId, onSelect }: SidebarProps) {
const [collapsed, setCollapsed] = useState(false);
return (
<aside
className={`fixed left-0 top-0 h-screen bg-sidebar z-50 flex flex-col transition-all duration-300 ${
collapsed ? 'w-16' : 'w-60'
}`}
>
<div className="flex items-center h-16 px-4 border-b border-white/10 shrink-0">
{!collapsed && (
<div className="flex items-center gap-3 overflow-hidden">
<div className="w-8 h-8 rounded-lg bg-gradient-to-br from-primary to-accent flex items-center justify-center">
<Layers className="w-5 h-5 text-white" />
</div>
<span className="text-white font-bold text-base whitespace-nowrap tracking-tight">
Automation
</span>
</div>
)}
{collapsed && (
<div className="w-8 h-8 rounded-lg bg-gradient-to-br from-primary to-accent flex items-center justify-center mx-auto">
<Layers className="w-5 h-5 text-white" />
</div>
)}
</div>
<nav className="flex-1 py-4 px-2 space-y-1 overflow-y-auto">
{NAV_ITEMS.map((item) => {
const Icon = item.icon;
const isActive = activeId === item.id;
return (
<button
key={item.id}
onClick={() => onSelect(item.id)}
className={`w-full flex items-center gap-3 px-3 py-2.5 rounded-lg text-sm font-medium transition-all duration-150 cursor-pointer ${
isActive
? 'bg-primary/20 text-primary border border-primary/30'
: 'text-slate-400 hover:text-white hover:bg-sidebar-hover border border-transparent'
} ${collapsed ? 'justify-center' : ''}`}
title={collapsed ? item.label : undefined}
>
<Icon className="w-5 h-5 shrink-0" />
{!collapsed && (
<>
<span className="truncate">{item.label}</span>
{item.badge && (
<span className="ml-auto bg-primary text-white text-[10px] font-bold px-1.5 py-0.5 rounded-full">
{item.badge}
</span>
)}
</>
)}
</button>
);
})}
</nav>
<div className="p-2 border-t border-white/10 shrink-0">
<button
onClick={() => setCollapsed(!collapsed)}
className="w-full flex items-center justify-center gap-2 px-3 py-2 text-slate-400 hover:text-white hover:bg-sidebar-hover rounded-lg text-sm transition-colors cursor-pointer"
>
{collapsed ? <ChevronRight className="w-4 h-4" /> : <ChevronLeft className="w-4 h-4" />}
{!collapsed && <span>收起菜单</span>}
</button>
</div>
</aside>
);
}

View File

@ -0,0 +1,96 @@
import { CheckCircle2, XCircle, Clock, Activity, TrendingUp } from 'lucide-react';
interface StatsRowProps {
total: number;
passed: number;
failed: number;
running: number;
duration: number;
}
interface StatCardDef {
key: string;
label: string;
icon: React.ElementType;
color: string;
bg: string;
border: string;
format: (v: number) => string;
trend?: string;
}
export default function StatsRow({ total, passed, failed, running, duration }: StatsRowProps) {
const passRate = total > 0 ? Math.round((passed / (passed + failed || 1)) * 100) : 0;
const cards: StatCardDef[] = [
{
key: 'total', label: '测试模块总数', icon: Activity,
color: 'text-primary', bg: 'bg-primary-light', border: 'border-primary/20',
format: (v) => `${v}`,
},
{
key: 'passRate', label: '通过率', icon: TrendingUp,
color: passRate === 100 ? 'text-success' : passRate >= 70 ? 'text-warning' : 'text-danger',
bg: passRate === 100 ? 'bg-green-50' : passRate >= 70 ? 'bg-amber-50' : 'bg-red-50',
border: passRate === 100 ? 'border-green-200' : passRate >= 70 ? 'border-amber-200' : 'border-red-200',
format: () => `${passRate}%`,
trend: passRate >= 90 ? '↑ 优秀' : passRate >= 70 ? '→ 良好' : '↓ 需关注',
},
{
key: 'passed', label: '通过', icon: CheckCircle2,
color: 'text-success', bg: 'bg-green-50', border: 'border-green-200',
format: (v) => `${v}`,
},
{
key: 'failed', label: '失败', icon: XCircle,
color: 'text-danger', bg: 'bg-red-50', border: 'border-red-200',
format: (v) => `${v}`,
},
{
key: 'duration', label: '总耗时', icon: Clock,
color: 'text-slate-600', bg: 'bg-slate-50', border: 'border-slate-200',
format: (v) => `${v}s`,
},
];
const values: Record<string, number> = { total, passed, failed, running, duration, passRate };
return (
<div className="grid grid-cols-5 gap-3 mb-6">
{cards.map((card) => {
const Icon = card.icon;
const val = values[card.key];
return (
<div
key={card.key}
className={`bg-card rounded-xl border ${card.border} p-4 hover:shadow-md hover:-translate-y-0.5 transition-all duration-200`}
>
<div className="flex items-center justify-between mb-3">
<span className="text-[11px] font-semibold text-text-secondary uppercase tracking-wider">{card.label}</span>
<div className={`w-8 h-8 ${card.bg} rounded-lg flex items-center justify-center`}>
<Icon className={`w-4 h-4 ${card.color}`} />
</div>
</div>
<div className="flex items-baseline gap-1">
<span className={`text-2xl font-bold tracking-tight ${card.color}`}>
{card.format(val)}
</span>
</div>
{card.trend && (
<div className="flex items-center gap-1 mt-1.5">
<span className={`text-[11px] font-medium ${
card.key === 'passRate'
? passRate >= 90 ? 'text-success' : passRate >= 70 ? 'text-warning' : 'text-danger'
: 'text-text-secondary'
}`}>
{card.trend}
</span>
</div>
)}
</div>
);
})}
</div>
);
}

View File

@ -0,0 +1,362 @@
import { useState, useCallback, useRef, useMemo } from 'react';
import { Play, Check, X, Loader2, RotateCw, Gauge, TestTube2 } from 'lucide-react';
import LogTerminal from './LogTerminal';
import type { LogEntry } from './LogTerminal';
import StatsRow from './StatsRow';
import TestResultRing from './TestResultRing';
import ActivityTable from './ActivityTable';
const API_BASE = 'http://localhost:8899';
interface Module {
id: string;
name: string;
description: string;
icon: React.ElementType;
color: string;
bg: string;
}
const MODULES: Module[] = [
{ id: 'workbench', name: '工作台', description: '核心工作流自动化测试', icon: Gauge, color: '#f97316', bg: 'bg-orange-50' },
{ id: 'data_space', name: '数据空间', description: '数据存储与访问验证', icon: TestTube2, color: '#3b82f6', bg: 'bg-blue-50' },
{ id: 'data_set', name: '数据集', description: '数据集管理流程测试', icon: TestTube2, color: '#8b5cf6', bg: 'bg-violet-50' },
{ id: 'monitor', name: '监控看板', description: '实时监控数据验证', icon: TestTube2, color: '#10b981', bg: 'bg-emerald-50' },
{ id: 'mirror_center', name: '镜像中心', description: '镜像仓库功能测试', icon: TestTube2, color: '#f59e0b', bg: 'bg-amber-50' },
{ id: 'image_manage', name: '图像管理', description: '图像处理管线测试', icon: TestTube2, color: '#ec4899', bg: 'bg-pink-50' },
{ id: 'model_workshop', name: '模型工作台', description: '模型训练与部署测试', icon: TestTube2, color: '#6366f1', bg: 'bg-indigo-50' },
{ id: 'cloud_desktop', name: '云端桌面', description: '远程桌面环境验证', icon: TestTube2, color: '#0891b2', bg: 'bg-cyan-50' },
{ id: 'dev_machine', name: '开发机', description: '开发环境可用性测试', icon: TestTube2, color: '#84cc16', bg: 'bg-lime-50' },
];
type ModuleStatus = 'idle' | 'running' | 'passed' | 'failed';
interface ModuleState {
status: ModuleStatus;
summary: string;
duration: number;
}
interface ActivityEntry {
id: string;
module: string;
status: 'passed' | 'failed' | 'running';
duration: number;
timestamp: string;
}
interface TestPanelProps {
activeModule: string | null;
}
export default function TestPanel({ activeModule }: TestPanelProps) {
const [modules, setModules] = useState<Record<string, ModuleState>>(() =>
Object.fromEntries(MODULES.map((m) => [m.id, { status: 'idle', summary: '就绪', duration: 0 }]))
);
const [logs, setLogs] = useState<LogEntry[]>([]);
const [logStatus, setLogStatus] = useState('就绪');
const [totalDuration, setTotalDuration] = useState(0);
const [activities, setActivities] = useState<ActivityEntry[]>([]);
const activityIdRef = useRef(0);
const logIdRef = useRef(0);
const runningRef = useRef<Map<string, EventSource>>(new Map());
const visibleModules = useMemo(() => {
if (!activeModule) return MODULES;
return MODULES.filter((m) => m.id === activeModule);
}, [activeModule]);
const stats = useMemo(() => {
const entries = Object.values(modules);
return {
total: MODULES.length,
passed: entries.filter((m) => m.status === 'passed').length,
failed: entries.filter((m) => m.status === 'failed').length,
running: entries.filter((m) => m.status === 'running').length,
duration: totalDuration,
};
}, [modules, totalDuration]);
const addLog = useCallback((msg: string, cls: string = '') => {
logIdRef.current += 1;
setLogs((prev) => [...prev, { id: logIdRef.current, msg, cls, timestamp: new Date().toLocaleTimeString() }]);
}, []);
const clearLogs = useCallback(() => {
setLogs([]);
setLogStatus('就绪');
}, []);
const addActivity = useCallback((module: string, status: 'passed' | 'failed' | 'running', duration: number) => {
activityIdRef.current += 1;
setActivities((prev) => [{
id: String(activityIdRef.current),
module,
status,
duration,
timestamp: new Date().toLocaleTimeString(),
}, ...prev.slice(0, 9)]);
}, []);
const setModuleState = useCallback((id: string, status: ModuleStatus, summary: string, duration: number = 0) => {
setModules((prev) => ({ ...prev, [id]: { status, summary, duration } }));
if (duration > 0) {
setTotalDuration((d) => d + duration);
}
}, []);
const runModuleTest = useCallback(
(moduleId: string) => {
const mod = MODULES.find((m) => m.id === moduleId);
if (!mod) return;
setModuleState(moduleId, 'running', '运行中...');
setLogStatus(`Running: ${mod.name}`);
addLog(`[${new Date().toLocaleTimeString()}] ▶ 启动 ${mod.name} 测试...`, 'text-cyan-400');
addActivity(mod.name, 'running', 0);
const es = new EventSource(`${API_BASE}/api/run-tests?module=${moduleId}`);
runningRef.current.set(moduleId, es);
es.onmessage = (e) => {
const data = JSON.parse(e.data);
if (data.type === 'log') {
addLog(data.msg, data.cls);
} else if (data.type === 'result') {
const newStatus = data.passed ? 'passed' : 'failed';
const statusIcon = newStatus === 'passed' ? '✓' : '✗';
const colorCls = newStatus === 'passed' ? 'text-green-400' : 'text-red-400';
addLog(
`[${new Date().toLocaleTimeString()}] ${statusIcon} ${mod.name} 测试${newStatus} · 耗时 ${data.duration}s`,
colorCls,
);
setModuleState(moduleId, newStatus as ModuleStatus, data.summary || '', data.duration || 0);
addActivity(mod.name, newStatus, data.duration || 0);
setLogStatus('就绪');
es.close();
runningRef.current.delete(moduleId);
}
};
es.onerror = () => {
addLog(`[${new Date().toLocaleTimeString()}] ✗ ${mod.name} 连接中断`, 'text-red-400');
setModuleState(moduleId, 'failed', '连接失败');
addActivity(mod.name, 'failed', 0);
setLogStatus('就绪');
es.close();
runningRef.current.delete(moduleId);
};
},
[addLog, addActivity, setModuleState],
);
const runAllTests = useCallback(() => {
clearLogs();
setTotalDuration(0);
setActivities([]);
setModules(
Object.fromEntries(MODULES.map((m) => [m.id, { status: 'idle' as ModuleStatus, summary: '就绪', duration: 0 }])),
);
addLog(`[${new Date().toLocaleTimeString()}] ═══ 开始执行全部测试 ═══`, 'text-white font-semibold');
MODULES.forEach((m, i) => {
setTimeout(() => runModuleTest(m.id), i * 400);
});
}, [clearLogs, addLog, runModuleTest]);
const resetAll = useCallback(() => {
runningRef.current.forEach((es) => es.close());
runningRef.current.clear();
setModules(
Object.fromEntries(MODULES.map((m) => [m.id, { status: 'idle', summary: '就绪', duration: 0 }])),
);
setTotalDuration(0);
setActivities([]);
clearLogs();
}, [clearLogs]);
const renderStatusBadge = (m: Module) => {
const state = modules[m.id];
switch (state.status) {
case 'running':
return (
<span className="inline-flex items-center gap-1 px-2 py-0.5 rounded-full text-[11px] font-medium bg-blue-100 text-blue-700">
<Loader2 className="w-3 h-3 animate-spin" /> 运行中
</span>
);
case 'passed':
return (
<span className="inline-flex items-center gap-1 px-2 py-0.5 rounded-full text-[11px] font-medium bg-green-100 text-green-700">
<Check className="w-3 h-3" /> 通过 <span className="opacity-60 ml-0.5">{state.duration}s</span>
</span>
);
case 'failed':
return (
<span className="inline-flex items-center gap-1 px-2 py-0.5 rounded-full text-[11px] font-medium bg-red-100 text-red-700">
<X className="w-3 h-3" /> 失败
</span>
);
default:
return (
<span className="inline-flex items-center gap-1 px-2 py-0.5 rounded-full text-[11px] font-medium bg-slate-100 text-slate-500">
就绪
</span>
);
}
};
const moduleCards = (
<div className={`grid gap-3 ${activeModule ? 'grid-cols-1' : 'grid-cols-1 md:grid-cols-2 xl:grid-cols-3'}`}>
{visibleModules.map((m) => {
const state = modules[m.id];
const Icon = m.icon;
const isRunning = state.status === 'running';
const isDone = state.status === 'passed' || state.status === 'failed';
return (
<div
key={m.id}
className={`relative group bg-card rounded-xl border transition-all duration-200 overflow-hidden ${
isRunning
? 'border-blue-200 shadow-md shadow-blue-100/50'
: state.status === 'passed'
? 'border-green-200 ring-1 ring-green-100'
: state.status === 'failed'
? 'border-red-200 ring-1 ring-red-100'
: 'border-border hover:border-slate-300 hover:shadow-md'
}`}
>
{isRunning && (
<div className="absolute top-0 left-0 right-0">
<div className="h-0.5 bg-gradient-to-r from-blue-400 via-blue-500 to-blue-600 animate-pulse" />
<div className="h-8 bg-gradient-to-t from-blue-50/0 to-blue-50/30" />
</div>
)}
<div className="p-4">
<div className="flex items-start justify-between mb-3">
<div className={`w-10 h-10 ${m.bg} rounded-xl flex items-center justify-center ring-1 ${isDone ? 'ring-slate-100' : 'ring-transparent'}`}>
<Icon className="w-5 h-5" style={{ color: m.color }} />
</div>
<div className="flex flex-col items-end gap-1.5">
{renderStatusBadge(m)}
</div>
</div>
<h3 className="font-semibold text-sm text-text-primary mb-1">{m.name}</h3>
<p className="text-xs text-text-secondary mb-3">{m.description}</p>
{isRunning && (
<div className="space-y-2 mb-3">
<div className="w-full bg-slate-100 rounded-full h-1.5 overflow-hidden">
<div className="h-full bg-gradient-to-r from-blue-400 to-blue-600 rounded-full animate-progress" />
</div>
<p className="text-[10px] text-blue-500 font-medium">测试执行中...</p>
</div>
)}
{isDone && (
<div className="space-y-2 mb-3">
<div className="w-full bg-slate-100 rounded-full h-1.5 overflow-hidden">
<div
className={`h-full rounded-full transition-all duration-500 ${
state.status === 'passed' ? 'bg-gradient-to-r from-green-400 to-green-500' : 'bg-gradient-to-r from-red-400 to-red-500'
}`}
style={{ width: '100%' }}
/>
</div>
<p className={`text-[10px] font-medium ${
state.status === 'passed' ? 'text-success' : 'text-danger'
}`}>
{state.status === 'passed' ? '✓ 完成' : '✗ 失败'} · {state.duration > 0 ? `${state.duration}s` : ''}
</p>
</div>
)}
{state.status === 'idle' ? (
<button
onClick={() => runModuleTest(m.id)}
className="w-full py-2 text-xs font-semibold text-primary bg-primary-light hover:bg-primary/10 rounded-lg transition-all hover:shadow-sm flex items-center justify-center gap-1.5 cursor-pointer"
>
<Play className="w-3.5 h-3.5" /> 运行测试
</button>
) : state.status === 'running' ? (
<div className="w-full py-2 text-xs font-medium text-blue-600/70 bg-blue-50/50 rounded-lg text-center">
等待测试完成...
</div>
) : (
<button
onClick={() => runModuleTest(m.id)}
className="w-full py-2 text-xs font-medium text-slate-500 bg-slate-50 hover:bg-slate-100 hover:text-slate-700 rounded-lg transition-all flex items-center justify-center gap-1.5 cursor-pointer"
>
<RotateCw className="w-3.5 h-3.5" /> 重新运行
</button>
)}
{state.summary && isDone && (
<p className="text-[10px] text-text-secondary mt-2 truncate bg-slate-50 rounded-md px-2 py-1">
{state.summary}
</p>
)}
</div>
</div>
);
})}
</div>
);
return (
<div>
<div className="flex items-center justify-between mb-5">
<div>
<h2 className="text-lg font-bold text-text-primary">
{activeModule ? `${MODULES.find((m) => m.id === activeModule)?.name} · 测试详情` : '自动化测试面板'}
</h2>
<p className="text-sm text-text-secondary mt-0.5">
{activeModule ? '查看该模块的详细测试进度与执行日志' : '按模块管理测试用例,支持单模块与全量回归'}
</p>
</div>
<div className="flex items-center gap-2">
<button
onClick={resetAll}
className="px-3 py-2 text-sm font-medium text-text-secondary hover:text-text-primary hover:bg-slate-100 rounded-lg transition-colors flex items-center gap-1.5 cursor-pointer"
>
<RotateCw className="w-4 h-4" /> 重置
</button>
{!activeModule ? (
<button
onClick={runAllTests}
className="px-5 py-2.5 bg-primary hover:bg-primary-dark text-white rounded-lg text-sm font-semibold transition-all flex items-center gap-2 cursor-pointer shadow-sm shadow-primary/25 hover:shadow-md hover:-translate-y-px"
>
<Play className="w-4 h-4 fill-white" /> 执行全部测试
</button>
) : (
<button
onClick={() => runModuleTest(activeModule)}
className="px-5 py-2.5 bg-primary hover:bg-primary-dark text-white rounded-lg text-sm font-semibold transition-all flex items-center gap-2 cursor-pointer shadow-sm shadow-primary/25 hover:shadow-md hover:-translate-y-px"
>
<Play className="w-4 h-4 fill-white" /> 运行此模块测试
</button>
)}
</div>
</div>
{!activeModule && <StatsRow {...stats} />}
{!activeModule ? (
<div className="grid grid-cols-1 xl:grid-cols-4 gap-4 mb-6">
<div className="xl:col-span-3">
{moduleCards}
</div>
<div className="space-y-4">
<TestResultRing passed={stats.passed} failed={stats.failed} total={stats.total} />
<ActivityTable items={activities} />
</div>
</div>
) : (
moduleCards
)}
<LogTerminal logs={logs} status={logStatus} onClear={clearLogs} />
</div>
);
}

View File

@ -0,0 +1,86 @@
import { PieChart, Pie, Cell, ResponsiveContainer } from 'recharts';
interface TestResultRingProps {
passed: number;
failed: number;
total: number;
}
const COLORS = {
passed: '#10b981',
failed: '#ef4444',
idle: '#e2e8f0',
};
export default function TestResultRing({ passed, failed, total }: TestResultRingProps) {
const idle = total - passed - failed;
const data = [
{ name: '通过', value: passed, color: COLORS.passed },
{ name: '失败', value: failed, color: COLORS.failed },
...(idle > 0 ? [{ name: '未运行', value: idle, color: COLORS.idle }] : []),
].filter((d) => d.value > 0);
const passRate = total > 0 ? Math.round((passed / total) * 100) : 0;
if (total === 0) {
return (
<div className="bg-card rounded-xl border border-border p-5 h-full flex flex-col items-center justify-center">
<div className="w-32 h-32 rounded-full border-3 border-slate-100 flex items-center justify-center mb-3">
<span className="text-2xl font-bold text-slate-300">--</span>
</div>
<p className="text-sm text-text-secondary">暂无测试数据</p>
</div>
);
}
return (
<div className="bg-card rounded-xl border border-border p-5 h-full">
<div className="flex items-center justify-between mb-3">
<h4 className="text-sm font-semibold text-text-primary">测试通过率</h4>
<span className={`text-lg font-bold ${passRate === 100 ? 'text-success' : passRate >= 70 ? 'text-warning' : 'text-danger'}`}>
{passRate}%
</span>
</div>
<div className="relative flex items-center justify-center">
<ResponsiveContainer width={160} height={160}>
<PieChart>
<Pie
data={data}
cx="50%"
cy="50%"
innerRadius={48}
outerRadius={72}
paddingAngle={2}
dataKey="value"
strokeWidth={0}
>
{data.map((entry, index) => (
<Cell key={`cell-${index}`} fill={entry.color} />
))}
</Pie>
</PieChart>
</ResponsiveContainer>
<div className="absolute inset-0 flex items-center justify-center pointer-events-none">
<div className="text-center">
<div className={`text-xl font-bold ${passRate === 100 ? 'text-success' : passRate >= 70 ? 'text-warning' : 'text-danger'}`}>
{passed}/{total}
</div>
</div>
</div>
</div>
<div className="flex justify-center gap-6 mt-3">
<div className="flex items-center gap-1.5">
<div className="w-2.5 h-2.5 rounded-full bg-success" />
<span className="text-xs text-text-secondary">通过 {passed}</span>
</div>
<div className="flex items-center gap-1.5">
<div className="w-2.5 h-2.5 rounded-full bg-danger" />
<span className="text-xs text-text-secondary">失败 {failed}</span>
</div>
</div>
</div>
);
}

View File

@ -0,0 +1,8 @@
export default function WelcomeSection() {
return (
<div className="mt-6 mb-8">
<h1 className="text-[40px] font-bold text-black">欢迎使用地瓜平台</h1>
<p className="text-gray-500 mt-2 text-lg">通过我们的集成工作台加速您的AI开发流程</p>
</div>
);
}

View File

@ -0,0 +1,57 @@
import { Eye, Terminal, ArrowRight } from 'lucide-react';
const WORKBENCHES = [
{
title: '视觉感知工作台',
description: '专为机器人行业算法工程师打造的一站式工程化解决方案,从数据生成、处理、训练、量化到模型部署。',
tags: ['数据生成', '模型训练', '量化部署'],
icon: Eye,
iconBg: 'bg-gradient-to-br from-orange-100 to-rose-100',
iconColor: 'text-orange-600',
},
{
title: '具身智能工作台',
description: '专为具身领域的大规模训练平台,提供可复用的仿真环境和项目模板,交互式开发调试环境。',
tags: ['仿真环境', '项目模板', '规模化训练'],
icon: Terminal,
iconBg: 'bg-gradient-to-br from-blue-100 to-indigo-100',
iconColor: 'text-blue-600',
},
];
export default function WorkbenchCards() {
return (
<div className="mb-8">
<div className="mb-5">
<h2 className="text-lg font-bold text-text-primary">产品工作台</h2>
<p className="text-sm text-text-secondary mt-0.5">选择适合您的工作台进行AI模型开发与测试</p>
</div>
<div className="grid grid-cols-1 xl:grid-cols-2 gap-4">
{WORKBENCHES.map((wb) => (
<div
key={wb.title}
className="group relative overflow-hidden rounded-xl bg-card border border-border hover:border-slate-300 hover:shadow-lg transition-all duration-200 cursor-pointer"
>
<div className="p-6">
<div className="flex items-start justify-between mb-4">
<div className={`p-3 rounded-xl ${wb.iconBg}`}>
<wb.icon className={`w-6 h-6 ${wb.iconColor}`} />
</div>
<ArrowRight className="w-5 h-5 text-slate-300 group-hover:text-primary group-hover:translate-x-0.5 transition-all" />
</div>
<h3 className="text-base font-bold text-text-primary mb-2">{wb.title}</h3>
<p className="text-sm text-text-secondary leading-relaxed mb-4 line-clamp-2">{wb.description}</p>
<div className="flex flex-wrap gap-2">
{wb.tags.map((tag) => (
<span key={tag} className="px-2.5 py-1 text-[11px] font-medium bg-slate-50 text-text-secondary rounded-md border border-border">
{tag}
</span>
))}
</div>
</div>
</div>
))}
</div>
</div>
);
}

View File

@ -0,0 +1,167 @@
import { useState, useEffect } from 'react';
import { useNavigate } from 'react-router-dom';
import { Play, CheckCircle2, AlertTriangle, Box, Layers, Database, ArrowRight, Zap } from 'lucide-react';
import { DCLOUD_NAV_ITEMS } from '../layout/navConfig';
interface DCloudDashboardProps {
onNavigate?: (id: string) => void;
}
export default function DCloudDashboard({ onNavigate }: DCloudDashboardProps) {
const navigate = useNavigate();
const [stats, setStats] = useState<Record<string, unknown> | null>(null);
useEffect(() => {
fetch('/api/dashboard/stats')
.then(r => r.json())
.then(setStats)
.catch(() => {});
}, []);
const handleNav = (id: string) => {
if (onNavigate) {
onNavigate(id);
} else {
navigate(`/dcloud/${id}`);
}
};
const overviewModules = DCLOUD_NAV_ITEMS.filter(i => i.section === 'overview' && i.id !== 'dashboard');
const coreModules = DCLOUD_NAV_ITEMS.filter(i => i.section === 'core');
const featureModules = DCLOUD_NAV_ITEMS.filter(i => i.section === 'modules');
return (
<div className="space-y-6">
<div className="bg-gradient-to-r from-[rgb(var(--color-surface))] to-[rgb(var(--color-surface-hover))] border border-[rgb(var(--color-border))] rounded-xl p-8">
<div className="flex items-center gap-4 mb-3">
<div className="w-12 h-12 rounded-xl bg-[rgb(var(--color-accent)/0.2)] flex items-center justify-center">
<Box className="w-6 h-6 text-[rgb(var(--color-accent))]" />
</div>
<div>
<h2 className="text-lg font-bold text-[rgb(var(--color-text-primary))]">D-Cloud 视觉感知工作台</h2>
<p className="text-sm text-[rgb(var(--color-text-secondary))]">覆盖 15 个业务模块的端到端自动化测试</p>
</div>
</div>
<div className="flex gap-2 mt-4">
<span className="px-2 py-1 bg-[rgb(var(--color-accent)/0.1)] text-[rgb(var(--color-accent))] text-[10px] rounded font-mono">Pytest</span>
<span className="px-2 py-1 bg-[rgb(var(--color-success)/0.1)] text-[rgb(var(--color-success))] text-[10px] rounded font-mono">Playwright</span>
<span className="px-2 py-1 bg-[rgb(var(--color-accent-amber)/0.1)] text-[rgb(var(--color-accent-amber))] text-[10px] rounded font-mono">E2E + API + UI + Flow</span>
</div>
</div>
{overviewModules.length > 0 && (
<div>
<div className="flex items-center gap-2 mb-4">
<Zap className="w-4 h-4 text-[rgb(var(--color-accent))]" />
<span className="text-sm font-medium text-[rgb(var(--color-text-primary))]">总览</span>
</div>
<div className="grid grid-cols-4 gap-3">
{overviewModules.map((mod) => (
<button
key={mod.id}
onClick={() => handleNav(mod.id)}
className="bg-[rgb(var(--color-surface))] border border-[rgb(var(--color-border))] rounded-xl p-5 text-left hover:border-[rgb(var(--color-accent)/0.5)] hover:bg-[rgb(var(--color-surface-hover))] transition-all cursor-pointer group"
>
<div className="w-10 h-10 rounded-lg bg-[rgb(var(--color-accent)/0.1)] flex items-center justify-center mb-3 group-hover:bg-[rgb(var(--color-accent)/0.2)] transition-colors">
<div className="text-[rgb(var(--color-accent))]">{mod.icon}</div>
</div>
<div className="text-sm font-medium text-[rgb(var(--color-text-primary))]">{mod.label}</div>
<div className="flex items-center gap-1 mt-2 text-xs text-[rgb(var(--color-accent))] opacity-0 group-hover:opacity-100 transition-opacity">
<Play className="w-3 h-3" />
运行测试
</div>
</button>
))}
</div>
</div>
)}
<div>
<div className="flex items-center gap-2 mb-4">
<Layers className="w-4 h-4 text-[rgb(var(--color-accent))]" />
<span className="text-sm font-medium text-[rgb(var(--color-text-primary))]">核心模块</span>
</div>
<div className="grid grid-cols-4 gap-3">
{coreModules.map((mod) => (
<button
key={mod.id}
onClick={() => handleNav(mod.id)}
className="bg-[rgb(var(--color-surface))] border border-[rgb(var(--color-border))] rounded-xl p-5 text-left hover:border-[rgb(var(--color-accent)/0.5)] hover:bg-[rgb(var(--color-surface-hover))] transition-all cursor-pointer group"
>
<div className="w-10 h-10 rounded-lg bg-[rgb(var(--color-accent)/0.1)] flex items-center justify-center mb-3 group-hover:bg-[rgb(var(--color-accent)/0.2)] transition-colors">
<div className="text-[rgb(var(--color-accent))]">{mod.icon}</div>
</div>
<div className="text-sm font-medium text-[rgb(var(--color-text-primary))]">{mod.label}</div>
<div className="flex items-center gap-1 mt-2 text-xs text-[rgb(var(--color-accent))] opacity-0 group-hover:opacity-100 transition-opacity">
<Play className="w-3 h-3" />
运行测试
</div>
</button>
))}
</div>
</div>
<div>
<div className="flex items-center gap-2 mb-4">
<Database className="w-4 h-4 text-[rgb(var(--color-accent))]" />
<span className="text-sm font-medium text-[rgb(var(--color-text-primary))]">功能模块</span>
</div>
<div className="grid grid-cols-4 gap-3">
{featureModules.map((mod) => (
<button
key={mod.id}
onClick={() => handleNav(mod.id)}
className="bg-[rgb(var(--color-surface))] border border-[rgb(var(--color-border))] rounded-xl p-4 text-left hover:border-[rgb(var(--color-accent)/0.5)] hover:bg-[rgb(var(--color-surface-hover))] transition-all cursor-pointer group"
>
<div className="flex items-center gap-3">
<div className="w-8 h-8 rounded-lg bg-[rgb(var(--color-accent)/0.1)] flex items-center justify-center group-hover:bg-[rgb(var(--color-accent)/0.2)] transition-colors shrink-0">
<div className="text-[rgb(var(--color-accent))] scale-75">{mod.icon}</div>
</div>
<div>
<div className="text-sm text-[rgb(var(--color-text-primary))]">{mod.label}</div>
<div className="flex items-center gap-1 mt-0.5 text-[10px] text-[rgb(var(--color-text-secondary))] group-hover:text-[rgb(var(--color-accent))] transition-colors">
<ArrowRight className="w-3 h-3" />
进入测试
</div>
</div>
</div>
</button>
))}
</div>
</div>
{stats && (
<div className="grid grid-cols-4 gap-4">
<div className="bg-[rgb(var(--color-surface))] border border-[rgb(var(--color-border))] rounded-xl p-4">
<div className="flex items-center gap-2">
<CheckCircle2 className="w-4 h-4 text-[rgb(var(--color-success))]" />
<span className="text-xs text-[rgb(var(--color-text-secondary))]">模块数</span>
</div>
<div className="text-xl font-bold text-[rgb(var(--color-text-primary))] mt-1">15</div>
</div>
<div className="bg-[rgb(var(--color-surface))] border border-[rgb(var(--color-border))] rounded-xl p-4">
<div className="flex items-center gap-2">
<Box className="w-4 h-4 text-[rgb(var(--color-accent))]" />
<span className="text-xs text-[rgb(var(--color-text-secondary))]">测试用例</span>
</div>
<div className="text-xl font-bold text-[rgb(var(--color-text-primary))] mt-1">~595</div>
</div>
<div className="bg-[rgb(var(--color-surface))] border border-[rgb(var(--color-border))] rounded-xl p-4">
<div className="flex items-center gap-2">
<Layers className="w-4 h-4 text-[rgb(var(--color-accent-amber))]" />
<span className="text-xs text-[rgb(var(--color-text-secondary))]">测试类型</span>
</div>
<div className="text-xl font-bold text-[rgb(var(--color-text-primary))] mt-1">E2E / API / UI / Flow</div>
</div>
<div className="bg-[rgb(var(--color-surface))] border border-[rgb(var(--color-border))] rounded-xl p-4">
<div className="flex items-center gap-2">
<AlertTriangle className="w-4 h-4 text-[rgb(var(--color-error))]" />
<span className="text-xs text-[rgb(var(--color-text-secondary))]">POM Mixins</span>
</div>
<div className="text-xl font-bold text-[rgb(var(--color-text-primary))] mt-1">10</div>
</div>
</div>
)}
</div>
);
}

View File

@ -1,145 +0,0 @@
import { useState, useEffect } from 'react'
import { useNavigate } from 'react-router-dom'
import {
GitBranch, ListTodo, FileText, FolderOpen, FlaskConical,
Play, Zap, Box, Layers, RefreshCw, Search, FileCode, Database,
} from 'lucide-react'
interface Stats {
tasks: { total: number; pass: number; fail: number; running: number; pass_rate: number }
reports: { total: number; pass: number; pass_rate: number }
repos: { total: number }
existing_tests: { modules: number }
}
export default function Dashboard() {
const [stats, setStats] = useState<Stats | null>(null)
const navigate = useNavigate()
useEffect(() => {
fetch('/api/dashboard/stats')
.then(r => r.json())
.then(setStats)
.catch(err => console.error('Dashboard stats fetch failed:', err))
}, [])
const quickActions = [
{ icon: <GitBranch size={20} />, label: '扫描仓库', desc: '添加 Git 仓库并自动分析', path: '/repos' },
{ icon: <FolderOpen size={20} />, label: '运行已有用例', desc: 'unified-test-platform 800+ 用例', path: '/existing' },
{ icon: <ListTodo size={20} />, label: '任务管理', desc: '查看实时任务状态和日志', path: '/tasks' },
{ icon: <FileText size={20} />, label: '测试报告', desc: '查看历史测试结果', path: '/reports' },
]
const capabilities = [
{ icon: <GitBranch size={16} />, title: 'Git 仓库扫描', desc: '自动拉取代码,AST 分析,DDD 领域建模' },
{ icon: <Zap size={16} />, title: 'LLM 测试生成', desc: 'TDD 红-绿-重构 + DDD 限界上下文划分' },
{ icon: <RefreshCw size={16} />, title: '精确回归', desc: 'git diff → 变更文件 → 限界上下文 → 自动筛选' },
{ icon: <Search size={16} />, title: '指标门禁', desc: '覆盖率 ≥ 60%,通过率 ≥ 95%' },
{ icon: <Box size={16} />, title: 'Session 领域', desc: '独立 Session 生命周期测试套件' },
{ icon: <FileCode size={16} />, title: '多语言支持', desc: 'Python / TypeScript / Go / Java' },
{ icon: <Layers size={16} />, title: '测试分层', desc: '冒烟 → 集成 → 回归 → E2E 全链路' },
{ icon: <Database size={16} />, title: '已有用例集成', desc: '直接运行 800+ 存量测试用例' },
]
return (
<div className="space-y-6">
<div className="bg-gradient-to-r from-[rgb(var(--color-surface))] to-[rgb(var(--color-surface-hover))] border border-[rgb(var(--color-border))] rounded-xl p-8">
<div className="flex items-center gap-4 mb-3">
<div className="w-12 h-12 rounded-xl bg-[rgb(var(--color-accent)/0.2)] flex items-center justify-center">
<FlaskConical className="w-6 h-6 text-[rgb(var(--color-accent))]" />
</div>
<div>
<h2 className="text-lg font-bold text-[rgb(var(--color-text-primary))]">TestAgent 智能测试平台</h2>
<p className="text-sm text-[rgb(var(--color-text-secondary))]">基于 LLM 的 TDD + DDD 自动化测试用例生成与管理</p>
</div>
</div>
<div className="flex gap-2 mt-4">
{['LLM + Pytest', 'TDD + DDD', 'AST 代码分析', 'E2E + API + UI'].map(tag => (
<span key={tag} className="px-2 py-1 bg-[rgb(var(--color-accent)/0.1)] text-[rgb(var(--color-accent))] text-[10px] rounded font-mono">{tag}</span>
))}
<span className="px-2 py-1 bg-[rgb(var(--color-success)/0.1)] text-[rgb(var(--color-success))] text-[10px] rounded font-mono">800+ 存量用例</span>
</div>
</div>
<div>
<div className="flex items-center gap-2 mb-4">
<Zap className="w-4 h-4 text-[rgb(var(--color-accent))]" />
<span className="text-sm font-medium text-[rgb(var(--color-text-primary))]">快速操作</span>
</div>
<div className="grid grid-cols-4 gap-3">
{quickActions.map(action => (
<button
key={action.label}
onClick={() => navigate(action.path)}
className="bg-[rgb(var(--color-surface))] border border-[rgb(var(--color-border))] rounded-xl p-5 text-left hover:border-[rgb(var(--color-accent)/0.5)] hover:bg-[rgb(var(--color-surface-hover))] transition-all cursor-pointer group"
>
<div className="w-10 h-10 rounded-lg bg-[rgb(var(--color-accent)/0.1)] flex items-center justify-center mb-3 group-hover:bg-[rgb(var(--color-accent)/0.2)] transition-colors">
<div className="text-[rgb(var(--color-accent))]">{action.icon}</div>
</div>
<div className="text-sm font-medium text-[rgb(var(--color-text-primary))]">{action.label}</div>
<div className="text-xs mt-1 text-[rgb(var(--color-text-secondary))]">{action.desc}</div>
<div className="flex items-center gap-1 mt-2 text-xs text-[rgb(var(--color-accent))] opacity-0 group-hover:opacity-100 transition-opacity">
<Play className="w-3 h-3" />
进入
</div>
</button>
))}
</div>
</div>
<div>
<div className="flex items-center gap-2 mb-4">
<Layers className="w-4 h-4 text-[rgb(var(--color-accent))]" />
<span className="text-sm font-medium text-[rgb(var(--color-text-primary))]">平台能力</span>
</div>
<div className="grid grid-cols-4 gap-3">
{capabilities.map(cap => (
<div
key={cap.title}
className="bg-[rgb(var(--color-surface))] border border-[rgb(var(--color-border))] rounded-xl p-4 text-left hover:border-[rgb(var(--color-accent)/0.3)] hover:bg-[rgb(var(--color-surface-hover))] transition-all"
>
<div className="flex items-center gap-2 mb-2">
<div className="text-[rgb(var(--color-accent))]">{cap.icon}</div>
<span className="text-xs font-medium text-[rgb(var(--color-text-primary))]">{cap.title}</span>
</div>
<div className="text-[11px] text-[rgb(var(--color-text-secondary))]">{cap.desc}</div>
</div>
))}
</div>
</div>
{stats && (
<div className="grid grid-cols-4 gap-4">
<div className="bg-[rgb(var(--color-surface))] border border-[rgb(var(--color-border))] rounded-xl p-4">
<div className="flex items-center gap-2">
<GitBranch className="w-4 h-4 text-[rgb(var(--color-accent))]" />
<span className="text-xs text-[rgb(var(--color-text-secondary))]">仓库</span>
</div>
<div className="text-xl font-bold text-[rgb(var(--color-text-primary))] mt-1">{stats.repos.total}</div>
</div>
<div className="bg-[rgb(var(--color-surface))] border border-[rgb(var(--color-border))] rounded-xl p-4">
<div className="flex items-center gap-2">
<ListTodo className="w-4 h-4 text-[rgb(var(--color-accent-amber))]" />
<span className="text-xs text-[rgb(var(--color-text-secondary))]">任务</span>
</div>
<div className="text-xl font-bold text-[rgb(var(--color-text-primary))] mt-1">{stats.tasks.total}</div>
</div>
<div className="bg-[rgb(var(--color-surface))] border border-[rgb(var(--color-border))] rounded-xl p-4">
<div className="flex items-center gap-2">
<Layers className="w-4 h-4 text-[rgb(var(--color-success))]" />
<span className="text-xs text-[rgb(var(--color-text-secondary))]">通过率</span>
</div>
<div className="text-xl font-bold text-[rgb(var(--color-text-primary))] mt-1">{stats.tasks.pass_rate.toFixed(1)}%</div>
</div>
<div className="bg-[rgb(var(--color-surface))] border border-[rgb(var(--color-border))] rounded-xl p-4">
<div className="flex items-center gap-2">
<FolderOpen className="w-4 h-4 text-[rgb(var(--color-accent))]" />
<span className="text-xs text-[rgb(var(--color-text-secondary))]">已有用例模块</span>
</div>
<div className="text-xl font-bold text-[rgb(var(--color-text-primary))] mt-1">{stats.existing_tests.modules}</div>
</div>
</div>
)}
</div>
)
}

Some files were not shown because too many files have changed in this diff Show More