乐于分享
好东西不私藏

人人都能做软件测试开发工程师:利用AI搭建测试平台

人人都能做软件测试开发工程师:利用AI搭建测试平台

在AI时代,借助AI工具,人人都可以搭建测试工具,人人都可以做软件测试开发工程师。
本文将详细介绍如何利于AI工具,一步步搭建测试平台。
一、编写需求.md
首先是编写本次的需求,以搭建自动化测试平台为例。
仅仅有一个搭建自动化测试平台的想法,无需具体思路,即可交给AI完成。只需要列出整体计划和原则。
核心目标:说明要做什么。
计划:列出整体计划,包括方案可行性评估、需求文档、技术方案、代码生成、自测用例等。整个计划跟产品需求过程一样,有完整的方案。
原则:多个方案供选择。确认后,方可执行下一步。
例如:
自动化测试平台核心目标:生成接口自动化平台。计划:1. 方案可行性评估;2. 写一个需求文档和设计稿;3. 写一个技术方案文档;4. 执行,生成代码;5. 生成自测用例;6. 自测通过;7. 整体检查一下是否按需求和技术方案实现;8. 生成使用文档。原则:1. 计划中,每一步,都需要出多个方案,找我确认,确认通过后,方可执行下一步。
整体流程图如下:
二、AI生成测试工具
编写好需求后,让AI执行。
在AI工具中输入:
读取文档并按文档执行:自动化测试平台-需求.md
执行结果如下:
读取文档并按文档执行:自动化测试平台-需求.md                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ⏺ 已读取《自动化测试平台-需求.md》。按文档原则,我将分 8 步推进,每步先提供多个方案供你确认,确认后再执行下一步。                                                                                                                                                                                                                                                                                                                                                                                                当前任务:Step 1 可行性分析与方案评估(进行中)。                                                                                                                                                                                                                                                                                                                                                                                                                                                               ---                                                                                                                                                                                                                                                     可行性分析结论                                                                                                                                                                                                                                                                                 构建“接口自动化测试平台”在技术上完全可行。核心是要在「测试用例管理」「请求执行引擎」「断言与报告」「调度与扩展」四个维度上做出取舍。                                                                                                                                                                                                                                                                                                                                                                           下面提供 3 个产品形态方案,请选择一个进入 Step 2(需求文档与设计稿)。                                                                                                                                                                                                                                                                                                                                                                                                                                         方案 A:Web 可视化平台(推荐)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 形态:浏览器访问的完整平台,支持多用户协作。                                                                                                                                                                                                            典型技术栈:                                                                                                                                                                                                                                            - 前端:Vue 3 / React + Element Plus / Ant Design                                                                                                                                                                                                     - 后端:Python FastAPI / Java Spring Boot                                                                                                                                                                                                               - 数据库:PostgreSQL / MySQL                - 执行引擎:pytest / httpx / requests + Celery 异步任务                                                                                                                                                                                                 - 报告:Allure / 自研 HTML 报告                                                                                                                                                                                                                                                                                                                                                                                                                                                                                适用场景:团队共用、权限管理、定时任务、历史记录、可视化报告。                                                                                                                                                                                          优点:功能最完整,扩展性最好,最符合“平台”定位。                                                                                                                                                                                                      缺点:开发量最大,需要前后端联调与部署。                                                                                                                                                                                                                                                                                                                                                                                                                                                                     ---                                                                                                                                                                                                                                                     方案 B:CLI / 本地工具平台                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      形态:命令行工具 + YAML/JSON 用例文件 + 本地报告。                                                                                                                                                                                                      典型技术栈:                                                                                                                                                                                                                                            - 语言:Python                                                                                                                                                                                                                                          - 用例格式:YAML / JSON                                                                                                                                                                                                                                 - 执行:Click + httpx + pytest                                                                                                                                                                                                                          - 报告:Jinja2 模板生成 HTML / Markdown                                                                                                                                                                                                                                                                                                                                                                                                                                                                       适用场景:个人或小团队、CI/CD 集成、快速落地、轻量维护。                                                                                                                                                                                                优点:开发快、易集成 Jenkins/GitHub Actions、无服务端成本。                                                                                                                                                                                             缺点:无可视化界面、协作能力弱、权限管理需额外实现。                                                                                                                                                                                                                                            ---                                                                                                                                                                                                                                                     方案 C:VS Code 插件平台                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       形态:VS Code 扩展,在编辑器内管理用例、运行、查看报告。                                                                                                                                                                                                典型技术栈:                                                                                                                                                                                                                                            - 插件:TypeScript + VS Code Extension API                                                                                                                                                                                                              - 执行后端:Python 本地进程 / Node 脚本                                                                                                                                                                                                                 - 存储:本地 JSON / SQLite                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     适用场景:开发者日常接口调试、轻量级自动化、与代码仓库紧密结合。                                                                                                                                                                                        优点:使用门槛低、与开发流程结合紧密、无需额外部署。                                                                                                                                                                                                    缺点:受限于编辑器生态、团队协作与远程执行能力弱。                                                                                                                                                                                                                                                                                                                                                                                                                                                              ---                                     需要你确认的问题                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. 选择哪个方案?(A / B / C,或提出修改意见)                                                                                                                                                                                                          2. 目标用户是谁?(前端/后端/测试工程师?团队规模?)                                                                                                                                                                                                   3. 是否需要定时任务 / CI 集成?                                                                                                                                                                                                                         4. 对技术栈有偏好吗?(例如必须用 Python/Java/Node)                                                                                                                                                                                                                                                                                                                                                                                                                                                            请回复你的选择,确认后我将进入 Step 2:需求文档与设计稿。                                                                                                                                                                                                                                                                                                                                                                                                                                                     ✻ Worked for 11s                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                8 tasks (0 done, 1 in progress, 7 open)                                                                                                                                                                                                                 ◼ Step 1: 可行性分析与方案评估              ◻ Step 3: 技术方案文档 › blocked by #6                                                                                                                                                                                                                     
从结果可以看出,在可行性分析阶段,AI从web页面、CLI、VS,由复杂到简单,列出多个方案,并说明每个方案的优缺点。同时待确认的问题2、3、4中,AI又补充了一些问题。例如目标用户,这个很重要的信息,AI帮我们想到了。
回复问题之后,AI继续执行:
❯ 1A方案;2. 测试工程师;3. 暂时不需要;4. python                                                                                                                                                                                                                                                ⏺ 确认收到:方案 A(Web 可视化平台)+ 面向测试工程师 + 暂不定时任务/CI + Python 技术栈。                                                                                                                                                                                                                                                                                                                                                                                                                         当前进入 Step 2:需求文档与设计稿(进行中)。                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ---                                                                                                                                                                                                                                                     一、功能模块设计(已按测试工程师场景细化)                                                                                                                                                                                                                                                                                                                                                                                                                                                                     ┌─────────┬───────────────────────────────────────────────────────────────────┐                                                                                                                                                               │   模块   │                                 核心功能                           │                                                                                                                                                                 ├─────────┼───────────────────────────────────────────────────────────────────┤                                                                                                                                                               │ 环境管理  │ 配置 base_url、全局 Header、全局变量(dev/test/prod)                  │                                                                                                                                                                 ├──────────┼───────────────────────────────────────────────────────────────────┤                                                                                                                                                               │ 接口管理  │ 维护接口元数据(URL、Method、Header、Params、Body)、支持 JSON/form-data │                                                                                                                                                                 ├──────────┼───────────────────────────────────────────────────────────────────┤  │ 用例管理  │ 基于接口组装测试用例、配置断言(状态码/JSON 字段/包含/等于)、变量提取         │                                                                                                                                                                 ├──────────┼───────────────────────────────────────────────────────────────────┤                                                                                                                                                                 │ 执行中心  │ 单用例调试、套件执行、实时日志、选择环境                                  │                                                                                                                                                                 ├──────────┼───────────────────────────────────────────────────────────────────┤                                                                                                                                                                 │ 报告中心  │ 执行结果列表、成功率、失败详情、请求/响应快照                              │                                                                                                                                                                 └──────────┴───────────────────────────────────────────────────────────────────┘                                                                                                                                                                                                                                                                                                                                                                                                                    ---                                                                                                                                                                                                                                                     二、数据模型设计(核心表)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   - user:用户                                                                                                                                                                                                                                                                                                                                                                                                                                                                - test_case:测试用例(关联 api + environment)                                                                                                                                                                                                       - suite_case:套件-用例关联(支持顺序)                                                                                                                                                                                                                                                                                                                                                                                                                                          - test_result:单个用例执行结果  ......                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ---                                     三、页面原型(文字版)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       1. 登录页:账号密码登录                                                                                                                                                                                                                                 2. ....                                                                                                                                                                                                           8. 报告页:列表 + 详情(请求/响应/断言结果)                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ---                                                                                                                                                                                                                                                     四、技术栈方案(请三选一)                                                                                                                                                                                                                                                                    方案 A1:现代前后端分离(推荐)                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - 前端:Vue 3 + Element Plus + Pinia + Axios                                                                                                                                                                                                            - 后端:FastAPI + SQLAlchemy 2.0 + Pydantic v2                                                                                                                                                                                                          - 数据库:PostgreSQL                                                                                                                                                                                                                                    - 执行引擎:httpx + 自定义执行器                                                                                                                                                                                                                        - 报告:自研 HTML / JSON 报告                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  优点:性能高、异步友好、类型安全、现代开发体验好。                                                                                                                                                                                                      缺点:前端构建部署稍复杂。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   ---                                                                                                                                                                                                                                                     方案 A2:轻量前后端分离                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         - 前端:React + Ant Design + Zustand                                                                                                                                                                                                                    - 后端:Flask + Flask-SQLAlchemy + Marshmallow                                                                                                                                                                                                          - 数据库:MySQL                                                                                                                                                                                                                                         - 执行引擎:requests + 自定义执行器                                                                                                                                                                                                                     - 报告:自研 HTML 报告                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         优点:技术栈成熟、资料多、上手快。                                                                                                                                                                                                                      缺点:Flask 异步能力弱于 FastAPI,大并发执行需额外处理。                                                                                                                                                                                                                                                                                                                                                                                                                                                     ---                                                                                                                                                                                                                                                     方案 A3:Django 全栈一体化                                                                                                                                                                                                                                                                     - 前端:Django Templates + Bootstrap / 少量 Vue                                                                                                                                                                                                         - 后端:Django + Django REST Framework                                                                                                                                                                                                                  - 数据库:SQLite(开发)/ PostgreSQL(生产)                                                                                                                                                                                                            - 执行引擎:requests                                                                                                                                                                                                                                    - 报告:Django 模板渲染 HTML                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   优点:框架一体化、Admin 后台自动生成、适合快速 MVP。                                                                                                                                                                                                    缺点:前后端耦合重,后续扩展可视化编辑器不如分离方案灵活。                                                                                                                                                                                                                                                                                                                                                                                                                                                  ---                                                                                                                                                                                                                                                     需要你确认                                                                                                                                                                                                                                                                                     1. 选择哪个技术栈方案?(A1 / A2 / A3)                                                                                                                                                                                                               2. 数据库有偏好吗?(默认跟随方案)                                                                                                                                                                                                                     3. 是否需要「接口管理」支持导入 Swagger/OpenAPI?                                                                                                                                                                                                     4. 报告形式偏好?(平台内嵌页面 / 可导出 HTML / 两者都要)                                                                                                                                                                                                                                                                                                                                                                                                                                                     确认后,我将进入 Step 3:技术方案文档。   
继续确认,AI执行:
1. A1;3. 需要接口管理;4. 平台内嵌页                                                                                                                                                                                                                                                           ⏺ 确认:方案 A1 + 需要 Swagger/OpenAPI 导入 + 平台内嵌报告页。                                                                                                                                                                                                                                                                                                                                                                                                                                                   当前进入 Step 3:技术方案文档(进行中)。                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ---                                                                                                                                                                                                                                                     一、技术栈确认                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ┌──────────┬──────────────────────────────────────────────────────┐                                                                                                                                                                                   │   层级    │                         选型                         │                                                                                                                                                                                     ├──────────┼──────────────────────────────────────────────────────┤                                                                                                                                                                                   │ 前端      │ Vue 3 + Element Plus + Pinia + Vue Router 4 + Axios  │                                                                                                                                                                                     ├──────────┼──────────────────────────────────────────────────────┤                                                                                                                                                                                   │ 后端      │ Python 3.11 + FastAPI + Pydantic v2 + SQLAlchemy 2.0 │                                                                                                                                                                                     ├──────────┼──────────────────────────────────────────────────────┤                                                                                                                                                                                   │ 数据库    │ PostgreSQL 15+                                       │                                                                                                                                                                                     ├──────────┼──────────────────────────────────────────────────────┤                                                                                                                                                                                   │ 执行引擎  │ httpx + 自定义执行器                                 │                                                                                                                                                                                     ├──────────┼──────────────────────────────────────────────────────┤  │ 报告     │ 平台内嵌报告页(前端表格 + 详情抽屉)                │                                                                                                                                                                                     └──────────┴──────────────────────────────────────────────────────┘                                                                                                                                                                                                                                                                                                                                                                                                                                           ---                                                                                                                                                                                                                                                     二、项目目录结构                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            api-test-platform/                                                                                                                                                                                                                                    ├── backend/                                                                                                                                                                                                                                            │   ├── app/                                                                                                                                                                                                                                          │   │   ├── api/           # 路由层                                                                                                                                                                                                                     │   │   ├── core/          # 配置、安全、日志                                                                                                                                                                                                         │   │   ├── db/            # 数据库连接、迁移                                                                                                                                                                                                           │   │   ├── models/        # SQLAlchemy 模型                                                                                                                                                                                                          │   │   ├── schemas/       # Pydantic 模型                                                                                                                                                                                                              │   │   ├── services/      # 业务逻辑                                                                                                                                                                                                                 │   │   ├── runner/        # 测试执行引擎                                                                                                                                                                                                               │   │   └── main.py        # FastAPI 入口  │   ├── alembic/           # 数据库迁移                                                                                                                                                                                                                 │   ├── tests/             # 后端单元测试                                                                                                                                                                                                             │   └── requirements.txt                 ├── frontend/                                                                                                                                                                                                                                           │   ├── src/                                                                                                                                                                                                                                            │   │   ├── api/           # Axios 封装                                                                                                                                                                                                                 │   │   ├── components/    # 业务组件                                                                                                                                                                                                                   │   │   ├── views/         # 页面                                                                                                                                                                                                                       │   │   ├── router/        # 路由                                                                                                                                                                                                                       │   │   ├── stores/        # Pinia                                                                                                                                                                                                                      │   │   └── main.js                                                                                                                                                                                                                                     │   └── package.json                                                                                                                                                                                                                                    ---                                                                                                                                                                                                                                                     三、数据库详细设计                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            -- 核心表                                                                                                                                                                                                                                               api(id, project_id, name, methodpathheadersparamsbody_typebodydescription)                                                                                                                                                                  test_case(idproject_idapi_idnameenvironment_idheadersparamsbody,                                                                                                                                                                                    extracts:listassertions:listcreated_at)                                                                                                                                                                                                   test_result(idrun_idcase_idstatusrequest_snapshotresponse_snapshot,                                                                                                                                                                                     assertion_resultserror_msgduration_ms)                                                                                                                                                                                                   ......                                                                                                                                                                                                                                                       ---                                                                                                                                                                                                                                                     四、关键接口设计                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ┌────────────────────┬──────── ──┐                                                                                                                                                                                                   │          接口       │   说明    │                                                                                                                                                                                                   ├────────────────────┼───────────┤                                                                                                                                                                                                                                                                                                                                                                                                │ CRUD /apis         │ 接口管理    │                                                                                                                                                                                                   ├────────────────────┼───────────┤                                                                                                                                                                                                   │ CRUD /test-cases   │ 用例管理    │                                                                                                                                                                                                                                                                                                                                                                                             └────────────────────┴───────────┘                                                                                                                                                                                                                                                                                                                                                                                                                                                       ---                                                                                                                                                                                                                                                     五、技术实现方案(请三选一)                                                                                                                                                                                                                                                                                                                                                                                                                                                                               方案 T1:全同步架构(简单可靠)                                                                                                                                                                                                                                                                                                                                                                                                                                                                             - 数据库:同步 SQLAlchemy + psycopg2     - 执行器:同步 httpx,测试执行直接在当前请求线程完成                                                                                                                                                                                                    - 适用:用例数量少、并发低、快速落地                                                                                                                                                                                                                                                                                                                                                                                                                                                                         优点:代码直观、调试简单、无需处理异步闭包。  缺点:执行大量用例时会阻塞 API 请求。                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ---                                                                                                                                                                                                                                                     方案 T2:全异步架构(高性能)                                                                                                                                                                                                                                                              - 数据库:异步 SQLAlchemy + asyncpg                                                                                                                                                                                                                     ......                                                                                                                                                                                                                                                                                                                                                                                                                                                                ---                                                                                                                                                                                                                                                   方案 T3:同步存储 + 异步执行(推荐)                                                                                                                                                                                                                                                                                                                                                                                                                                                                           - 数据库:同步 SQLAlchemy(业务 CRUD 简单可靠)  - 执行器:测试执行放入 ThreadPoolExecutor 或后台任务,避免阻塞 API                                                                                                                                                                                      - 适用:平衡开发效率与执行性能                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 优点:业务层写同步代码,执行层异步解耦,维护成本最低。                                                                                                                                                                                                  缺点:执行状态需通过轮询或 WebSocket 获取。                                                                                                                                                                                                                                                                                                                                                                                                                                           ---                                                                                                                                                                                                                                                     需要你确认                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     1. 选择哪个技术实现方案?(T1 / T2 / T3)                                                                                                                                                                                                               2. 测试执行状态如何通知前端?(轮询 / WebSocket / 执行完成后直接返回同步结果)                                                                                                                                                                          3. 变量语法偏好?({{var}} / ${var} / 两种都支持)                                                                                                                                                                                                                                                        确认后,我将进入 Step 4:代码实现。                         
继续确认,并针对不确定的方案,进一步提问,AI执行:
❯ 1. T3;2. 通知前端的3个方式列出各自优缺点,再进一步选择;3. ${var}                                                                                                                                                                                                                       ⏺ 确认:方案 T3(同步存储 + 异步执行)+ 不用 Docker + 变量语法 ${var}。                                                                                                                                                                                                                                                                                                                                                                                                                                          针对问题 2,下面是三种前端通知方式的详细对比,请选择一个。                                                                                                                                                                                                                                                                                                                                                                                                                                               ---                                                                                                                                                                                                                                                     前端执行状态通知方案对比                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     方案 N1:同步等待返回                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        机制:调用 POST /test-suites/{id}/run 后,后端启动后台线程执行,API 一直 Hold 住,等全部用例执行完再一次性返回结果。                                                                                                                                                                                                                                                                                                                                                                                      ┌─────────────────────────────────┬───────────────────────────────────┐                                                                                                                                                                    │                 优点             │                  缺点              │                                                                                                                                                                      ├─────────────────────────────────┼───────────────────────────────────┤                                                                                                                                                                    │ 实现最简单,前端无需轮询或 WebSocket │ 请求可能被 Nginx/浏览器超时(默认 60s) │                                                                                                                                                                      ├─────────────────────────────────┼────────────────────────────────────┤                                                                                                                                                                    │ 用户直接拿到完整报告                │ 执行期间无法看到实时进度                │                                                                                                                                                                      ├─────────────────────────────────┼────────────────────────────────────┤  │ 无需额外协议                      │ 大套件容易超时失败                     │                                                                                                                                                                      └─────────────────────────────────┴────────────────────────────────────┘                                                                                                                                                                                                                                                                                                                                                                                                                            适用:套件规模小、追求简单、对实时进度无要求。                                                                                                                                                                                                                                                                                                                                                                                                                                                             ---                                                                                                                                                                                                                                                     方案 N2:轮询(Polling)                                                                                                                                                                                                                                                                     机制:调用 POST /test-suites/{id}/run 立即返回 run_id,前端每隔 1~2 秒请求 GET /test-runs/{run_id} 获取最新状态与结果。                                                                                                                                                                                                                                                                                                                                                                                      ┌──────────────────────────┬──────────────────────┐                                                                                                                                                                                           │             优点          │           缺点        │                                                                                                                                                                                           ├──────────────────────────┼───────────────────────┤                                                                                                                                                                                         │ 实现简单,兼容所有浏览器/代理 │ 实时性一般,有 1~2 秒延迟 │                                                                                                                                                                                           ├─────────────────────── ──┼───────────────────────┤                                                                                                                                                                                         │ 不依赖长连接,稳定可靠       │ 持续产生额外请求         │                                                                                                                                                                                           ├──────────────────────────┼───────────────────────┤                                                                                                                                                                                         │ 可展示实时进度与中间结果      │ 服务器有一定空轮询压力    │                                                                                                                                                                                           └──────────────────────────┴───────────────────────┘                                                                                                                                                                                                                                                        适用:通用方案、无需极致实时、部署简单。                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ---                                                                                                                                                                                                                                                     方案 N3:WebSocket 实时推送                                                                                                                                                                                                                                                                   机制:建立 WebSocket 连接,执行过程中后端按步骤推送 started/running/completed 事件与单条结果。                                                                                                                                                                                                                                                                                                                                                                                                                  ┌────────────────────┬──────────────────────────────┐                                                                                                                                                                                       │          优点       │                 缺点          │                                                                                                                                                                                       ├────────────────────┼───────────────────────────────┤                                                                                                                                                                                     │ 实时性最好,用户体验佳 │ 实现复杂度最高                   │                                                                                                                                                                                       ├────────────────────┼───────────────────────────────┤                                                                                                                                                                                     │ 无轮询开销           │ 需要处理连接管理、断线重连、代理兼容 │                                                                                                                                                                                       ├────────────────────┼───────────────────────────────┤                                                                                                                                                                                     │ 可展示执行日志流      │ 对服务器连接数有要求              │                                                                                                                                                                                       └────────────────────┴───────────────────────────────┘                                                                                                                                                                                                                                                          适用:对实时进度要求高、团队有 WebSocket 运维经验。                                                                                                                                                                                                                                                                                                                                                                                                                                                             ---                                                                                                                                                                                                                                                     需要你确认                                                                                                                                                                                                                                                                                  1. 选择哪种通知方式?(N1 / N2 / N3)                                                                                                                                                                                                                   2. 如果选 N2 轮询,可接受轮询间隔多少秒?(默认 2 秒)                                                                                                                                                                                                  3. 是否需要在报告中展示每个请求的「请求头/请求体/响应头/响应体」完整快照?(是 / 否)                                                                                                                                                                                                                                                                                                                                                                                                                        确认后,我将完成 Step 3 技术方案文档并进入 Step 4:代码实现。                                                                                                                                                                                                                                                                                                                                                                                                                                          

继续确认,AI执行:

 ⏺ Step 3 已确认:N2 轮询(2 秒间隔)+ 报告展示完整请求/响应快照。                                                                                                                                                                                                                                                                                                                                                                                                                                              我先把前面两步的决策落盘为文档,然后进入 Step 4:代码实现。 Write(docs/01-需求与设计.md)                                                                                                                                                                                                                            ⎿  Wrote 54 lines to docs/01-需求与设计.md                                                                                                                                                                                                                   1 # 自动化测试平台 - 需求文档与设计稿                                                                                                                                                                                                                                                                                                                                                                                                                                                              3 ## 1. 项目背景与目标                                                                                                                                                                                                                                4                                                                                                                                                                                                                                                       5 构建一个面向测试工程师的 Web 端接口自动化测试平台,支持接口管理、用例编写、套件组织、执行调试与报告查看。                                                                                                                                           6                                                                                                                                                                                                                                                       7 ## 2. 目标用户                                                                                                                                                                                                                                      8                                                                                                                                                                                                                                                       9 - 主要用户:测试工程师                                                                                                                                                                                                                              … +44 lines (ctrl+o to expand)                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ⏺ Write(docs/02-技术方案.md)                                                                                                                                                                                                                              ⎿  Wrote 120 lines to docs/02-技术方案.md                                                                                                                                                                                                                  1 # 自动化测试平台 - 技术方案文档                                                                                                                                                                                                                       2                                                                                                                                                                                                                                                       3 ## 1. 技术栈                                                                                                                                                                                                                                          4                                                                                                                                                                                                                                                       5 | 层级 | 选型 |                                                                                                                                                                                                                                       6 |---|---|                                                                                                                                                                                                                                             7 | 前端框架 | Vue 3 + Element Plus + Pinia + Vue Router 4 + Axios |     … +110 lines (ctrl+o to expand)                                                                                                                                                                                                                     ⏺ 文档已落盘:                                                                                                                                                                                                                                            - docs/01-需求与设计.md                                                                                                                                                                                                                               - docs/02-技术方案.md                                                               当前进入 Step 4:代码实现(进行中)。                   

接下来,开始生成代码和自测用例。

三、效果展示

代码生成后,目录如下:

前端登录/注册页面如下:

注册成功后,登录后:

新建接口:

新建用例:

套件管理:

四、总结

仅仅只需要写一个非常简单的需求文档,定义好规范。仅用一两个小时,一行代码都不需要写,AI就可以搭建一个功能齐全的自动化测试平台。

人人都可以做测试开发工程师的时代来了!