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
# Run: pytest --cov --cov-report=html --cov-report=term
# Run: pytest --cov=tests --cov-report=html --cov-report=term
[run]
source = backend, agent, framework, plugins
source = tests
omit =
*/__init__.py
tests/*
frontend/*
work/*
tests/__init__.py
tests/*/__init__.py
tests/*/tests/__init__.py
[report]
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
OPENAI_API_KEY=sk-your-api-key-here
OPENAI_BASE_URL=https://ai-api.d-robotics.cc/v1
# 复制此文件为 .env 并填入实际值
# cp .env.example .env
# ===========================================
# 测试平台登录凭证
# 必需配置
# ===========================================
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 允许的来源(逗号分隔,生产环境必须设置)
CORS_ORIGINS=http://localhost:5174,http://127.0.0.1:5174,http://localhost:5002
# 无头模式(CI 环境建议 true)
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

84
.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
__pycache__/
*.pyc
*.pyo
*.py[cod]
*.egg-info/
.pytest_cache/
.mypy_cache/
.ruff_cache/
dist/
build/
.venv/
.venv311/
venv/
# 前端
frontend/node_modules/
frontend/dist/
frontend/pnpm-lock.yaml
frontend/tsconfig*.tsbuildinfo
# Environment
.env
.env.local
# Docs (local only)
docs/
# Auth
.auth/
# Outputs
reports/
screenshots/
logs/
*.log
# IDE
.idea/
.vscode/
.idea/
*.swp
*.swo
# macOS
.DS_Store
# OS
.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
# 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
# 2. 启动后端
python -m backend
# 访问 http://localhost:5002
# 4. 安装 Playwright 浏览器
playwright install chromium
# 3. 前端开发(可选)
cd frontend && pnpm install && pnpm dev
# 访问 http://localhost:5174
# 5. 构建前端
cd frontend
pnpm install
pnpm build
cd ..
```
### CLI 命令行
### 启动
```bash
# 扫描仓库并生成测试
python main.py run -r https://github.com/user/repo.git -k sk-your-api-key
# 方式一:直接启动 Flask 后端(含前端)
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` | 统计概览(仓库/任务/报告/已有用例)+ 快速操作入口 |
| **仓库管理** | `/repos` | 添加 Git 仓库 → 扫描 → DDD 分析 → 生成测试 → 精确回归 → 全流程一键执行 |
| **任务管理** | `/tasks` | 任务列表 + 实时 SSE 日志流 + 停止/删除 |
| **测试报告** | `/reports` | 报告列表 + 详细日志 + 失败截图查看 |
| **已有用例** | `/existing` | 浏览 unified-test-platform 的 22 个模块 800+ 用例,按模块/标记运行 |
| `/dcloud` | D-Cloud (ToB) | 16 个模块卡片仪表盘,点击进入模块测试 |
| `/dcloud/e2e` | E2E 全量测试 | API 全链路(8条) + UI 点击(3条) + 分步测试(3个) |
| `/dcloud/:module` | 模块测试页 | 一键运行 pytest,SSE 实时日志流 |
| `/robogo` | Robogo (ToC) | 全链路巡检仪表盘,趋势图、健康度分析 |
| `/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 生成测试 |
| `diff` | 精确回归 — 只对 git diff 变更文件生成测试,自动映射限界上下文 |
| `analyze` | 领域分析 — 只分析 DDD 领域模型,不调用 LLM(免费) |
| 测试文件 | 68 个 |
| 收集到的测试 | 856 个(含参数化) |
| E2E 测试 | 40 个(`-m e2e`) |
| 业务模块 | 16 个 |
## 测试类型
## License
```
smoke 冒烟测试 — 核心主流程快速验证
unit 单元测试 — 领域层纯逻辑,Mock 隔离所有外部依赖
integration 集成测试 — 跨模块/跨服务接口联动
regression 回归测试 — 代码变更后精确回归
e2e 端到端测试 — 完整业务流程黑盒验证
```
Internal use — D-Robotics
## 5 步流水线
---
```
┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
│ 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+ 用例 |
**AutoFlow v2.0** — 从双平台到统一平台

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.scheduler import Scheduler
if __name__ == "__main__":
app.run(
host=os.getenv("FLASK_HOST", "127.0.0.1"),
port=int(os.getenv("FLASK_PORT", "5002")),
debug=os.getenv("FLASK_DEBUG", "0") == "1",
threaded=True,
)
print("Unified Test Platform starting... http://127.0.0.1:5001")
Scheduler().start()
app.run(host="0.0.0.0", port=5001)

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 random
import sys
import uuid
from pathlib import Path
from typing import Dict, Type
from urllib.parse import urlparse
@ -78,10 +77,6 @@ class BaseConfig:
LOGIN_URL = ""
# Robogo 认证
AUTH_TOKEN: str = os.getenv("AUTH_TOKEN", "")
COOKIE: str = os.getenv("AUTH_COOKIE", "")
DEFAULT_TIMEOUT: int = 15000
SHORT_WAIT: int = 200
MEDIUM_WAIT: int = 500
@ -105,73 +100,32 @@ class BaseConfig:
REPORT_DIR: str = "tests/features/reports"
# Robogo resources
FOLDER_NAME = f"UI_TEST_{uuid.uuid4().hex[:8]}"
DEV_MACHINE_NAME = f"UI_TEST_{uuid.uuid4().hex[:8]}"
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 = os.getenv("SSH_PUBLIC_KEY", "")
SSH_PUBLIC_KEY = "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIBGp6Be0pt0Xy3Ipxm+AQTz6JQq8DAzIU6XHqD+/gzH6"
SYSTEM_DISK = "100"
CLOUD_DESKTOP_SKU = "desktop-5880gpu12g-16c32g"
CLOUD_DESKTOP_NAME = f"UI_TEST_{uuid.uuid4().hex[:8]}"
MIRROR_NAME = f"UI_TEST_{uuid.uuid4().hex[:8]}"
CLOUD_DESKTOP_NAME = f"UI_TEST_{random.randint(1, 1000000)}"
MIRROR_NAME = f"UI_TEST_{random.randint(1, 1000000)}"
MIRROR_SKU = "desktop-5880gpu12g-16c32g"
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
WAIT = {
'create': 60,
'stop': 30,
'start': 30,
'switch': 15,
'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
PLATFORM_PORT = int(os.getenv("PLATFORM_PORT", "5001"))
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):
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")

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 config.settings import Config
from framework.core.base_api import BaseAPI
from framework.config.settings import Config
class BillingService(APIClient):
class BillingService(BaseAPI):
def __init__(self):
super().__init__(Config.CLOUD_BASE_URL, Config.CLOUD_AUTH_TOKEN)

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@ -1,66 +1,53 @@
from framework.core.base_ui import BaseUI
from config.settings import Config
from tests.logger import get_logger
from framework.config.settings import Config
from framework.core.logger import get_logger
import time
logger = get_logger("LoginPage")
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"
SUCCESS_INDICATOR = ".ant-layout-sider, .user-name"
def __init__(self, headless=False):
super().__init__(headless=headless)
def login(self, username, password):
"""执行登录流程"""
login_url = f"{Config.BASE_URL}/login"
# 直接使用 Config.LOGIN_URL
login_url = Config.LOGIN_URL
self.navigate(login_url)
logger.info("等待登录页面加载...")
self.wait_for_selector(self.USERNAME_INPUT)
self.fill(self.USERNAME_INPUT, username)
self.fill(self.PASSWORD_INPUT, password)
logger.info("正在点击登录按钮...")
time.sleep(1)
self.click(self.LOGIN_BUTTON)
logger.info("登录请求已发送,等待进入系统...")
try:
# 1. 强制等待关键 UI 元素出现 (证明已经跳过 SSO 到了主页)
self.page.wait_for_selector(self.SUCCESS_INDICATOR, timeout=10000)
# 2. 二次确认 URL 是否已经离开 SSO,回到业务主域名
if "robogo-fat" in self.page.url:
logger.info(f"🎉 登录流程圆满成功!进入主系统 URL: {self.page.url}")
return True
except Exception as e:
logger.warning(f"等待主站 UI 加载超时 (可能是 SSO 跳转慢): {e}")
logger.info("正在实时监控重定向链路...")
success_flag = {"done": False}
def _check_url(frame):
url = frame.url if hasattr(frame, "url") else str(frame)
if "/setting/profile" in url or "bearer=" in url or "/app-center" in url:
logger.info(f"⌛ 侦测到重定向轨迹: {url[:80]}...")
success_flag["done"] = True
self.page.on("framenavigated", _check_url)
start_time = time.time()
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
# 兜底:如果还是在 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
return True

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@ -2,8 +2,8 @@ import time
import os
import random
import string
from tests.base.base_page import BasePage
from tests.logger import get_logger
from framework.core.base_page import BasePage
from framework.core.logger import get_logger
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
from tests.logger import get_logger
logger = get_logger("SmartInteraction")
logger = get_logger("BasePage")
class BasePage:
"""所有页面对象的基类,提供智能识别与常用操作封装"""
def __init__(self, page):
self.page = page
class SmartInteractionMixin:
"""提供语义化点击、填写、选择等交互操作,带 JS 暴力兜底"""
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):
"""语义化点击:带重试与可见性校验"""
logger.info(f"👉 [SmartClick] 尝试点击: {text}")
try:
el = self.smart_find(text, role=role, timeout=timeout)
# 等待可见与稳定
el.wait_for(state="visible", timeout=timeout)
# 使用自带重试的点击逻辑,应对 SPA 瞬时刷新
try:
el.click(timeout=timeout)
except Exception as e:
@ -23,6 +56,7 @@ class SmartInteractionMixin:
else:
raise e
except Exception as e:
# 暴力循环 JS 点击作为最终兜底
success = self.page.evaluate(f"""(txt) => {{
const target = Array.from(document.querySelectorAll('button, a, span, .p-button-label, label, input'))
.find(el => {{
@ -31,10 +65,10 @@ class SmartInteractionMixin:
const ph = el.getAttribute('placeholder') || "";
return it.includes(txt) || al.includes(txt) || ph.includes(txt);
}});
if (target) {{
if (target) {{
target.scrollIntoView({{behavior: "smooth", block: "center"}});
setTimeout(() => target.click(), 100);
return true;
setTimeout(() => target.click(), 100);
return true;
}}
return false;
}}""", text)
@ -42,7 +76,7 @@ class SmartInteractionMixin:
raise e
def smart_click_any(self, texts, role=None, timeout=5000):
"""按多个候选文案点击,兼容新旧页面元素文案"""
"""按多个候选文案点击,兼容新旧页面元素文案。"""
last_error = None
for text in texts:
try:
@ -53,8 +87,32 @@ class SmartInteractionMixin:
logger.info(f" 候选元素未命中 [{text}]: {e}")
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):
"""点击表格/卡片行内操作,兼容文本按钮、aria、tooltip 和图标按钮"""
"""点击表格/卡片行内操作,兼容文本按钮、aria、tooltip 和图标按钮。"""
icon_classes = icon_classes or []
logger.info(f"👉 [RowAction] 在 [{row_text}] 容器内点击 [{action_label}]")
@ -111,7 +169,7 @@ class SmartInteractionMixin:
if loc.count() and loc.is_visible(timeout=500):
loc.click()
return True
except Exception:
except:
continue
raise Exception(f"❌ 未找到 [{row_text}] 的行内操作 [{action_label}]")
@ -119,25 +177,29 @@ class SmartInteractionMixin:
"""语义化输入:支持 Vue/React 的深度绑定注入"""
logger.info(f"⌨️ [SmartFill] 在 [{label}] 填写: {value}")
try:
# 1. 尝试直接命中 (Label/Placeholder等原生属性)
el = self.smart_find(label, timeout=timeout)
el.wait_for(state="visible", timeout=timeout)
el.fill(value, timeout=timeout)
except Exception as first_err:
try:
# 2. 邻近注入方案:借助 JS 寻找关联输入框,并使用 Playwright 原生 fill 保障前端框架双向绑定
logger.info(f"🔍 [SmartFill] 常规规则未命中,正在执行深度邻近探测 [{label}]...")
success = self.page.evaluate(f"""(lbl) => {{
document.querySelectorAll('[data-smart-target]').forEach(e => e.removeAttribute('data-smart-target'));
// 1. 过滤:必须是有高度/宽度的真实可见节点
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));
// 2. 最深层过滤
const tags = allNodes.filter(el => {{
return !Array.from(el.children).some(child => child.offsetWidth > 0 && child.innerText && child.innerText.includes(lbl));
}});
for (const t of tags) {{
const container = t.closest('.p-inputgroup, .field, .flex, div');
const input = container?.querySelector('input:not([type="hidden"]), textarea') ||
const input = container?.querySelector('input:not([type="hidden"]), textarea') ||
t.parentElement?.querySelector('input:not([type="hidden"]), textarea');
if (input && input.offsetWidth > 0) {{
input.setAttribute('data-smart-target', 'true');
@ -146,7 +208,7 @@ class SmartInteractionMixin:
}}
return false;
}}""", label)
if success:
target = self.page.locator("[data-smart-target='true']").first
target.scroll_into_view_if_needed()
@ -159,7 +221,7 @@ class SmartInteractionMixin:
logger.error(f"⚠️ [SmartFill] JS注入或执行时发生错误: {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}")
try:
el = self.smart_find(text, role=role, timeout=timeout)
@ -172,7 +234,8 @@ class SmartInteractionMixin:
def smart_select(self, label, value):
"""智能下拉框选择 (适配 PrimeVue)"""
logger.info(f"📋 [SmartSelect] 在 [{label}] 下拉框寻找目标: {value}")
# 1. 寻找并打开下拉框
opened = self.page.evaluate("""([lbl, val]) => {
const root = document.querySelector('.p-dialog') || document.querySelector('[role="dialog"]') || document;
const elements = Array.from(root.querySelectorAll('label, span, div'));
@ -180,18 +243,20 @@ class SmartInteractionMixin:
const t = el.innerText?.trim();
return t && (t === lbl || t.includes(lbl)) && el.offsetWidth > 0;
});
if (!targetLabel) return 'NO_LABEL';
let container = targetLabel;
for (let i = 0; i < 8; i++) {
if (!container) break;
// 查找下拉框容器
const dd = container.querySelector('.p-select, .p-dropdown, [data-pc-name="select"], [data-pc-name="dropdown"]');
if (dd && dd.offsetWidth > 0) {
dd.scrollIntoView({block: 'center'});
dd.click();
return 'OPENED';
}
// 检查兄弟元素
if (container.parentElement) {
const sibling = container.parentElement.querySelector('.p-select, .p-dropdown, [data-pc-name="select"]');
if (sibling && sibling.offsetWidth > 0) {
@ -204,14 +269,16 @@ class SmartInteractionMixin:
}
return 'NO_DROPDOWN';
}""", [label, value])
if opened != 'OPENED':
logger.warning(f"⚠️ [SmartSelect] 无法精准找到标签 '{label}' 关联的下拉框,尝试直接搜索首个 visible 的下拉框...")
self.page.locator(".p-select, .p-dropdown").first.click()
time.sleep(1)
# 2. 尝试多种定位器点击选项
try:
# 优先精准文本
selectors = [
f"li[role='option']:has-text('{value}')",
f".p-select-option:has-text('{value}')",
@ -223,9 +290,10 @@ class SmartInteractionMixin:
loc.click()
logger.info(f"✅ [SmartSelect] 成功通过选择器选中: {value}")
return True
except Exception:
except:
pass
# 3. JS 暴力匹配并点击
clicked = self.page.evaluate("""(val) => {
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));
@ -240,5 +308,5 @@ class SmartInteractionMixin:
if clicked:
logger.info(f"✅ [SmartSelect] 通过 JS 暴力匹配选中: {value}")
return True
raise Exception(f"❌ [SmartSelect] 无法在下拉框中选择选项: {value}")
raise Exception(f"❌ [SmartSelect] 无法在下拉框中选择选项: {value}")

View File

@ -2,7 +2,7 @@
UI 自动化基类占位 (推荐使用 Playwright)
"""
from playwright.sync_api import sync_playwright
from tests.logger import get_logger
from framework.core.logger import get_logger
import time
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
import time
from config.settings import Config
from tests.logger import get_logger
from framework.config.settings import Config
from framework.core.logger import get_logger
logger = get_logger("ComputeResourceScenario")

View File

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

View File

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

View File

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

View File

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

View File

@ -1,6 +1,6 @@
import time
import random
from tests.logger import get_logger
from framework.core.logger import get_logger
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")

View File

@ -1,7 +1,7 @@
import time
import random
import string
from tests.logger import get_logger
from framework.core.logger import get_logger
from framework.business.quantization_page import QuantizationPage
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
from tests.logger import get_logger
from framework.core.logger import get_logger
logger = get_logger("ThreeDAssetsScenario")

View File

@ -1,8 +1,8 @@
import os
import random
import time
from tests.logger import get_logger
from config.settings import Config
from framework.core.logger import get_logger
from framework.config.settings import Config
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>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>TestAgent | 智能测试平台</title>
<title>AutoFlow | 统一自动化测试平台</title>
</head>
<body>
<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 { ThemeProvider } from './context/ThemeContext'
import ErrorBoundary from './components/ErrorBoundary'
import Layout from './components/layout/Layout'
import Dashboard from './components/dashboard/Dashboard'
import ReposView from './components/repos/ReposView'
import TasksView from './components/tasks/TasksView'
import ReportsView from './components/reports/ReportsView'
import ExistingTestsView from './components/existing/ExistingTestsView'
import './index.css'
import { BrowserRouter, Routes, Route, Navigate } from 'react-router-dom';
import { ThemeProvider } from './context/ThemeContext';
import Layout from './components/layout/Layout';
import DCloudDashboard from './components/dashboard/DCloudDashboard';
import RobogoDashboard from './components/dashboard/RobogoDashboard';
import TestModuleView from './components/test/TestModuleView';
import E2ETestView from './components/test/E2ETestView';
import TasksView from './components/tasks/TasksView';
import ReportsView from './components/reports/ReportsView';
import './index.css';
export default function App() {
return (
<ErrorBoundary>
<ThemeProvider>
<BrowserRouter>
<Routes>
<Route element={<Layout />}>
<Route index element={<Dashboard />} />
<Route path="dashboard" element={<Dashboard />} />
<Route path="repos" element={<ReposView />} />
<Route path="tasks" element={<TasksView />} />
<Route path="reports" element={<ReportsView />} />
<Route path="existing" element={<ExistingTestsView />} />
<Route path="*" element={<Navigate to="/" replace />} />
</Route>
</Routes>
</BrowserRouter>
</ThemeProvider>
</ErrorBoundary>
)
<ThemeProvider>
<BrowserRouter>
<Routes>
<Route element={<Layout />}>
<Route index element={<Navigate to="/dcloud" replace />} />
<Route path="dcloud" element={<DCloudDashboard />} />
<Route path="dcloud/e2e" element={<E2ETestView />} />
<Route path="dcloud/:module" element={<TestModuleView />} />
<Route path="robogo" element={<RobogoDashboard />} />
<Route path="robogo/tasks" element={<TasksView />} />
<Route path="robogo/reports" element={<ReportsView />} />
<Route path="*" element={<Navigate to="/dcloud" replace />} />
</Route>
</Routes>
</BrowserRouter>
</ThemeProvider>
);
}

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