# AgentTest

**Repository Path**: Hello_Tester/AgentTest

## Basic Information

- **Project Name**: AgentTest
- **Description**: AI智能自动化测试平台
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 1
- **Created**: 2026-06-29
- **Last Updated**: 2026-06-29

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# AI智能测试平台

***

## 一、系统架构

### 1.系统构成

#### 前端

- 技术栈 ：Vue 3 + Vite + Element Plus + Pinia + Vue Router + Axios + CodeMirror
- 核心模块 ：
  - 用户管理（登录/注册/用户列表）
  - 项目选择
  - 项目管理（仪表盘、模块、环境、成员）
  - 功能测试（需求导入、用例、AI生成用例）
  - 接口测试（接口导入、接口管理、接口依赖、基础用例、自动化用例、测试套件、执行计划、测试报告）

#### 后端

- 技术栈 ：Python + FastAPI + Tortoise ORM + MySQL + JWT
- 核心模块 ：
  - 用户管理、项目管理、测试环境、功能测试、接口测试、测试管理、测试执行
  - AI工作流：功能用例生成、接口用例生成（接口基础用例生成、可执行接口用例生成）
  - 接口文档解析：OpenAPI解析器/Swagger解析器/AI智能解析器
  - 执行引擎： api\_case\_run （BaseTestCase / TestExecute）
  - 外挂知识库：Lightrag

### 2.架构图

```mermaid
flowchart TB
    subgraph External[外部依赖]
        LLM[大模型服务<br/>DeepSeek / SiliconFlow]
        MySQL[(MySQL 数据库)]
        LightRAG[LightRAG 知识库<br/>外挂/预留]
    end

    subgraph Frontend[前端层 Vue3 + Vite]
        Pinia[Pinia 状态管理]
        Router[Vue Router]
        Axios[Axios HTTP请求]
        EP[Element Plus UI组件]
        CM[CodeMirror 代码编辑器]

        subgraph FrontendModules[前端业务模块]
            FM_User[用户登录/注册/管理]
            FM_Project[项目管理<br/>模块/环境/成员/仪表盘]
            FM_Functional[功能测试<br/>需求/用例/AI生成]
            FM_Api[接口测试<br/>接口导入/接口管理/基础用例/自动化用例<br/>依赖/套件/计划/报告]
            FM_UI[UI测试<br/>用例/页面]
        end

        Pinia --> FrontendModules
        Router --> FrontendModules
        Axios -->|HTTP| BackendAPI
    end

    subgraph Backend[后端层 FastAPI + Tortoise ORM]
        Auth[JWT 认证]
        BackendAPI[REST API 路由]

        subgraph BackendService[业务服务模块]
            S_User[user 用户管理]
            S_Project[project 项目管理]
            S_Env[environment 测试环境]
            S_Func[functional_test 功能测试]
            S_Api[api_test 接口测试]
            S_Mgmt[test_mgmt 测试管理]
            S_Exec[test_execution 测试执行]
        end

        subgraph Parser[接口文档解析]
            OpenAPI[openai_document_parser<br/>OpenAPI 3.0]
            Swagger[swagger_document_parser<br/>Swagger 2.0]
            AI_Parser[ai_parser_api_document<br/>AI解析]
        end

        subgraph AIWorkflow[AI工作流引擎 LangGraph]
            subgraph ApiMainFlow[接口用例生成主流程<br/>api_case_generator_main_workflow]
                WF_ApiBase[api_basecase_workflow<br/>生成基础用例]
                WF_ApiRun[api_run_case_workflow<br/>生成可执行用例+预执行]
            end

            WF_CaseGen[case_generator_workflow<br/>功能用例生成]
        end

        subgraph Prompts[提示词模板]
            P_Workflow[config/prompts/workflow]
            P_ApiCase[config/prompts/api_case_work]
        end

        subgraph Execution[测试执行引擎]
            Execute[execute.py 任务/套件/用例执行器]
            BaseCase[basecase.py 单条用例执行]
            DBClient[database_client.py 数据库客户端]
            TestResult[test_result.py 结果记录]
        end
    end

    BackendAPI --> BackendService
    BackendAPI --> Parser
    Parser -->|解析后的接口文档| WF_ApiBase
    WF_ApiBase -->|基础用例| WF_ApiRun
    WF_ApiRun -->|调用预执行| Execution

    AIWorkflow --> Prompts
    BackendService --> MySQL
    Prompts --> LLM
    LightRAG -.->|预留| LLM
```

### 3.架构说明

| 层级/模块        | 说明                                                                                                                                                                     |
| ------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **前端层**      | 基于 Vue 3 + Vite 构建的单页应用，使用 Element Plus 作为 UI 组件库，Pinia 管理用户登录等全局状态，Axios 统一调用后端 API，CodeMirror 用于环境全局工具函数的 Python 脚本编辑。                                               |
| **后端层**      | 基于 FastAPI 提供 RESTful API，Tortoise ORM 操作 MySQL 数据库，JWT 完成认证与权限校验。                                                                                                     |
| **业务服务模块**   | 按领域拆分为用户、项目、测试环境、功能测试、接口测试、测试管理、测试执行七大模块。                                                                                                                              |
| **接口文档解析**   | 提供 OpenAPI 3.0、Swagger 2.0 与 AI 智能解析三种方式，将接口文档转换为统一结构接口，供接口用例生成工作流使用。                                                                                                  |
| **AI 工作流引擎** | 基于 LangGraph 实现。`case_generator_workflow` 负责从需求文档生成功能测试用例；`api_case_generator_main_workflow` 编排 `api_basecase_workflow`（生成基础用例）与 `api_run_case_workflow`（生成可执行用例并预执行）。 |
| **提示词模板**    | `config/prompts/workflow` 与 `config/prompts/api_case_work` 目录下存放各工作流节点使用的 LLM 提示词模板。                                                                                   |
| **测试执行引擎**   | `api_case_run` 模块负责实际执行接口用例，核心包括 `TestExecute`（任务/套件/用例调度）与 `BaseTestCase`（单条用例执行、变量替换、前后置脚本、断言、数据提取）。                                                                 |
| **外部依赖**     | 大模型服务（DeepSeek / SiliconFlow）提供 LLM 能力；MySQL 持久化业务数据；LightRAG 作为外挂知识库预留，暂未深度集成到功能用例生成流程。                                                                               |

***

### 4.前端示例

![图1](./img/img1.png)

![图2](./img/img2.png)

***

## 二、部分模块核心逻辑

### 1.工作流

#### 1. 根据需求文档生成测试用例

##### 1.1 流程图

```mermaid
flowchart TD
    %% 主流程
    M_START([START]) --> M1[生成测试点<br/>generator_point]
    M1 --> M2[生成测试用例<br/>generate_test_case]
    M2 --> M3[验证测试用例覆盖率<br/>verify_testcase_coverage]
    M3 -->|未覆盖全部测试点| M2
    M3 -->|已覆盖全部测试点| M4[保存测试用例<br/>save_test_cases]
    M4 --> M_END([END])

    %% 子流程
    subgraph GeneratorPointWorkflow [子工作流：测试点生成]
        direction TB
        S_START([START]) --> S1[生成测试点<br/>generate_test_points]
        S1 --> S2[验证测试点覆盖率<br/>verify_test_points_coverage]
        S2 --> S3{路由分发<br/>route_dispatch}
        S3 -->|测试点未全部覆盖| S1
        S3 -->|测试点已经全部覆盖| S4[输出所有测试点<br/>output_all_test_points]
        S4 --> S_END([END])
    end

    %% 子流程与主流程的连接
    M1 -.->|进入子流程| S_START
    S_END -.->|返回测试点列表| M1
```

***

##### 1.2 测试点转功能用例

需求文档（示例）

```markdown
 # 功能说明文档：
## 📌 F1.1 用户注册
### 🧩 功能背景
新用户通过注册方式创建账户，支持邮箱/用户名+密码的注册方式。

### 🚶 主流程
1. 用户打开注册页，填写注册信息
2. 系统校验格式与唯一性（用户名、邮箱）
3. 提交注册，后台创建账户，初始状态为"正常"
4. 注册成功后自动登录并跳转首页

### ⚠️ 异常流程
- 邮箱/用户名已被注册：提示"已存在"
- 两次密码不一致：提示用户重新输入

### 📌 状态规则
- 新用户状态为 "正常"
- 注册时间记录为创建时间，头像为默认图

### 📌 业务规则
- 用户名唯一，支持 4~20 位字母数字组合
- 密码长度不少于 06rag使用案例.py 位
- 邮箱必须符合格式 `xxx@xxx.xx`
```

转 测试点：

```json
[
    {
		"type": "正向验证",
		"test_point": "输入正确的用户名和密码，成功登录"
	},
	{
		"type": "正向验证",
		"test_point": "登录后跳转到正确的页面"
	},
	{
		"type": "边界测试",
		"test_point": "用户名长度为最小值时登录"
	},
	{
		"type": "异常处理",
		"test_point": "输入错误的用户名，提示\"用户名不存在\""
	},
    ...
]
```

转 功能用例：

```json
[
    {
		"case_id": "用例编号",
		"case_name": "用例名称",
		"priority": "优先级",
		"preconditions": "前置步骤",
		"test_steps": "测试步骤",
		"test_data": "输入数据",
		"expected_result": "预期结果",
		"actual_result": "实际结果"
    },
    ...
]
```

***

#### 2. 根据接口生成接口测试用例

##### 2.1 流程图

```mermaid
flowchart TD
    %% 顶层主流程
    START([START]) --> M1[生成基础用例<br/>generator_base_case]
    M1 --> M2{并发生成可执行用例}
    M2 -->|Send / gather| R1[生成可执行用例<br/>generate_run_api_case]
    R1 --> M3[保存所有用例<br/>output_save_all_case]
    M3 --> END1([END])

    %% 子工作流1：api_basecase_workflow
    subgraph SW1 [子工作流1：api_basecase_workflow 生成基础测试用例]
        direction TB
        S1_START([START]) --> S1_1[生成基础测试用例<br/>generator_base_case]
        S1_1 --> S1_2[检查用例的覆盖率<br/>check_coverage]
        S1_2 --> S1_3{验证覆盖率是否通过<br/>check_coverage_is_pass}
        S1_3 -->|未通过| S1_4[补充基础测试用例<br/>supplement_case]
        S1_4 --> S1_2
        S1_3 -->|通过| S1_5[保存基础测试用例<br/>save_base_case]
        S1_5 --> S1_END([END<br/>返回 base_cases])
    end

    %% 子工作流2：api_run_case_workflow
    subgraph SW2 [子工作流2：api_run_case_workflow 生成并预执行单条接口用例]
        direction TB
        S2_START([START]) --> S2_1[加载工具函数和文件列表<br/>get_functions_and_files]
        S2_1 --> S2_2[生成接口用例<br/>generator_api_case]
        S2_2 --> S2_3[用例预执行<br/>api_case_run]
        S2_3 --> S2_4{验证用例是否可用<br/>check_case_is_pass}
        S2_4 -->|不可用且未达3次| S2_2
        S2_4 -->|可用 或 已重试3次| S2_5[保存用例<br/>save_api_case]
        S2_5 --> S2_END([END<br/>返回 api_case])
    end

    %% 调用关系
    M1 -.->|调用子工作流1| S1_START
    S1_END -.->|返回基础用例列表| M1
    M2 -.->|对每条基础用例调用| S2_START
    S2_END -.->|返回单条可执行用例| R1
```

***

##### 2.2 接口文档（接口解析器解析后）转基础用例转接口用例

接口文档（示例）

```json
{
	"path": "API路径",
	"method": "HTTP方法(GET/POST/PUT/DELETE等)",
	"summary": "接口的简要名称",
	"parameters": {
		"header": [{
			"name": "参数名",
			"type": "参数类型",
			"description": "参数说明",
			"required": true / false
		}],
		"path": [{
			"name": "参数名",
			"type": "参数类型",
			"description": "参数说明",
			"required": true / false
		}],
		"query": [{
			"name": "参数名",
			"type": "参数类型",
			"description": "参数说明",
			"required": true / false
		}]
	},
	"requestBody": {
		"content_type": "请求体类型，如 application/json，无请求体时为null",
		"body": [{
				"name": "字段名",
				"type": "string|integer|boolean|number等基础类型",
				"description": "字段说明",
				"required": true / false
			},
			{
				"name": "对象字段名",
				"type": "object",
				"description": "对象字段说明",
				"required": true / false,
				"nested_fields": [{
					"name": "嵌套字段名",
					"type": "字段类型",
					"description": "嵌套字段说明",
					"required": true / false
				}]
			},
			{
				"name": "数组字段名",
				"type": "array",
				"description": "数组字段说明",
				"required": true / false,
				"array_item_fields": [{
					"name": "数组元素字段名",
					"type": "字段类型",
					"description": "数组元素字段说明",
					"required": true / false
				}]
			}
		]
	},
	"responses": [{
		"http_code": "状态码",
		"description": "响应描述",
		"media_type": "响应内容类型，如 application/json",
		"response_body": {
			"示例响应数据": "值"
		}
	}]
}
```

转 基础用例

```json
[
    {
		"name": "测试用例名称",
		"steps": [
			"步骤描述1",
			"步骤描述2"
		],
		"expected": [
			"预期结果断言1",
			"预期结果断言2"
		],
		"dependencies": ["前置条件依赖数据接口1", "前置条件依赖数据接口2"]
    },
    ...
]
```

转 接口用例

```json
{
	"name": "用例名称（简明描述本用例目标，例如：正常请求-注册成功）",
	"description": "用例描述（对测试场景进行简要说明，如：验证用户注册接口在输入正确参数时返回成功）",
	"interface": "接口名称或接口路径（与被测主接口对应，例如 /api/users/register）",
	"preconditions": [{
		"name": "前置步骤名称（说明依赖接口的用途，例如：用户登录获取token）",
		"request": {
			"interface_id": "前置接口ID（唯一标识，可与接口文档保持一致）",
			"method": "HTTP方法（如：GET、POST、PUT、DELETE）",
			"url": "接口路径（如 /api/users/login）",
			"base_url": "测试环境的基础地址（固定引用环境变量，例如：${{base_url}}）",
			"headers": {
				"请求头信息（必须包含Content-Type，若需鉴权则包含Authorization）"
			},
			"params": {
				"查询参数（URL上的?key=value形式参数，若无则为{}）"
			},
			"body": {
				"请求体（application/json请求体参数，若无则为{}）"
			},
			"files": {
				"仅multipart/form-data时使用，文件参数需从文件列表选择，非文件参数也放在此处"
			},
			"setup_script": "前置脚本（Python代码，用于生成动态数据并保存环境变量，禁止直接写死到body）",
			"teardown_script": "后置脚本（Python代码，用于清理或提取必要数据，若无则为\"\"）"
		},
		"extract": [
			["变量名", "jmespath表达式（从接口响应中提取的字段路径，例如 token 或 data.id）"]
		]
	}],
	"request": {
		"interface_id": "主接口ID（唯一标识，用于区分不同接口）",
		"method": "HTTP方法（如：POST）",
		"url": "接口路径（例如 /api/users/register）",
		"base_url": "测试环境的基础地址（必须写为 ${{base_url}}）",
		"headers": {
			"请求头信息（必须根据接口类型配置，例如 application/json 或 multipart/form-data）"
		},
		"params": {
			"查询参数（键值对形式，若无则为{}）"
		},
		"body": {
			"请求体参数（所有测试数据必须用 ${{变量}} 引用，不能硬编码）"
		},
		"files": {
			"当Content-Type为multipart/form-data时必填，否则固定为{}"
		},
		"setup_script": "前置脚本（Python代码，用于生成本用例需要的动态变量，调用global_function后必须用test.save_test_env_variables保存）",
		"teardown_script": "后置脚本（Python代码，执行清理或额外数据提取，若无则为\"\"）"
	},
	"assertions": {
		"response": [{
			"type": "断言类型（仅支持 equal / not_null / http_code；http_code用于断言响应状态码）",
			"field": "响应字段路径（jmespath表达式，例如 data.id；当 type=http_code 时，此处固定为 http_code）",
			"expected": "预期值（equal需与实际值一致，not_null固定为true，http_code为期望的状态码）"
		}]
	}
}
```

***

### 2. 接口用例执行器

&#x20;流程图

```mermaid
flowchart TD
    A[execute_test_task<br/>执行测试任务] --> B{遍历 suites_list}
    B --> C1[suite 1]
    B --> C2[suite 2]
    B --> C3[suite N]

    C1 --> D1[execute_test_suite<br/>执行测试套件]
    C2 --> D2[execute_test_suite<br/>执行测试套件]
    C3 --> D3[execute_test_suite<br/>执行测试套件]

    D1 --> E1{遍历 cases_list}
    D2 --> E2{遍历 cases_list}
    D3 --> E3{遍历 cases_list}

    E1 --> F1[execute_test_case<br/>执行单条用例]
    E2 --> F2[execute_test_case<br/>执行单条用例]
    E3 --> F3[execute_test_case<br/>执行单条用例]

    F1 --> G[创建 TestResult]
    F2 --> G
    F3 --> G

    G --> H{skip?}
    H -->|是| I[status = skip<br/>直接返回]
    H -->|否| J[BaseTestCase.run<br/>执行用例核心逻辑]

    J --> K[execute_preconditions<br/>执行前置依赖]
    K --> L[replace_variables<br/>变量替换]
    L --> M[request_api<br/>发送请求]
    M --> N[extract_data<br/>数据提取]
    N --> O[assert_result<br/>断言校验]

    O --> P{异常类型?}
    P -->|无异常| Q[status = success]
    P -->|AssertionError| R[status = failed<br/>记录错误信息]
    P -->|其他异常| S[status = error<br/>记录 traceback]

    Q --> T[finally: http.aclose]
    R --> T
    S --> T

    T --> U[计算 duration<br/>返回 TestResult]

    I --> V[汇总套件 summary]
    U --> V

    V --> W{所有套件执行完毕?}
    W -->|否| B
    W -->|是| X[汇总任务 summary<br/>返回结果]
```