103 |
--------------------------------------------------------------------------------
/apps/__init__.py:
--------------------------------------------------------------------------------
1 | # 空文件，使apps成为一个Python包
--------------------------------------------------------------------------------
/apps/agents/__init__.py:
--------------------------------------------------------------------------------
1 | # 空文件，使agents成为一个Python包
--------------------------------------------------------------------------------
/apps/agents/analyser.py:
--------------------------------------------------------------------------------
1 | from typing import Dict, Any, List, Optional
2 | import json
3 | import logging
4 |
5 | from ..llm.base import BaseLLMService
6 | from ..knowledge.service import KnowledgeService
7 | from .prompts import PrdAnalyserPrompt
8 | from langchain_core.messages import SystemMessage, HumanMessage
9 | from utils.logger_manager import get_logger
10 |
11 | class PrdAnalyserAgent:
12 | """PRD分析Agent，用于从PRD文档中提取测试点和测试场景"""
13 |
14 | def __init__(self, llm_service: BaseLLMService, knowledge_service: KnowledgeService = None):
15 | self.llm_service = llm_service
16 | self.knowledge_service = knowledge_service
17 | self.prompt = PrdAnalyserPrompt()
18 | self.logger = get_logger(self.__class__.__name__)
19 |
20 | def analyse(self, markdown_content: str) -> Dict[str, Any]:
21 | """
22 | 分析PRD文档，提取测试点和测试场景
23 |
24 | Args:
25 | markdown_content: Markdown格式的PRD文档内容
26 |
27 | Returns:
28 | 包含测试点和测试场景的字典，格式为：
29 | {
30 | "test_points": [...],
31 | "summary": {...}
32 | }
33 | """
34 | try:
35 | self.logger.info(f"开始分析PRD文档，文档长度：{len(markdown_content)} 字符")
36 |
37 | # 使用prompt模板格式化消息
38 | messages = self.prompt.format_messages(markdown_content=markdown_content)
39 |
40 | self.logger.info(f"构建后的PRD分析提示词: \n{'='*50}\n{messages}\n{'='*50}")
41 |
42 | # 调用LLM服务
43 | response = self.llm_service.invoke(messages)
44 | result = response.content
45 |
46 | # 解析JSON结果
47 | try:
48 | if "```json" in result:
49 | json_str = result.split("```json")[1].split("```")[0].strip()
50 | elif "```" in result:
51 | json_str = result.split("```")[1].split("```")[0].strip()
52 | else:
53 | json_str = result
54 |
55 | analysis_result = json.loads(json_str)
56 | self.logger.info(f"成功解析PRD分析结果，包含测试点数量：{len(analysis_result.get('test_points', []))}")
57 |
58 | # 验证分析结果
59 | self._validate_analysis_result(analysis_result)
60 |
61 | return analysis_result
62 |
63 | except json.JSONDecodeError as e:
64 | self.logger.error(f"解析JSON结果失败: {str(e)}")
65 | self.logger.error(f"原始响应: {result}")
66 | raise ValueError(f"无法解析生成的分析结果: {str(e)}")
67 |
68 | except Exception as e:
69 | self.logger.error(f"PRD分析过程出错: {str(e)}", exc_info=True)
70 | raise Exception(f"PRD分析失败: {str(e)}")
71 |
72 | def _validate_analysis_result(self, result: Dict[str, Any]) -> bool:
73 | """
74 | 验证分析结果是否符合预期格式
75 |
76 | Args:
77 | result: 分析结果字典
78 |
79 | Returns:
80 | 如果符合格式返回True，否则抛出异常
81 | """
82 | # 检查是否包含测试点列表
83 | if "test_points" not in result or not isinstance(result["test_points"], list):
84 | raise ValueError("分析结果缺少有效的test_points列表")
85 |
86 | # 检查测试点是否包含必要字段
87 | for i, point in enumerate(result["test_points"]):
88 | required_fields = ["id", "title", "description", "priority", "scenarios"]
89 | for field in required_fields:
90 | if field not in point:
91 | raise ValueError(f"测试点 #{i+1} 缺少必要字段: {field}")
92 |
93 | # 验证每个测试点的scenarios列表
94 | if not isinstance(point["scenarios"], list):
95 | raise ValueError(f"测试点 #{i+1} 的scenarios不是有效的列表")
96 |
97 | # 验证scenarios中的每个场景
98 | for j, scenario in enumerate(point["scenarios"]):
99 | scenario_fields = ["id", "title", "description", "test_type"]
100 | for field in scenario_fields:
101 | if field not in scenario:
102 | raise ValueError(f"测试点 #{i+1} 的测试场景 #{j+1} 缺少必要字段: {field}")
103 |
104 | # 检查汇总信息
105 | if "summary" not in result or not isinstance(result["summary"], dict):
106 | raise ValueError("分析结果缺少有效的summary信息")
107 |
108 | summary_fields = ["total_test_points", "total_test_scenarios",
109 | "high_priority_points", "medium_priority_points", "low_priority_points"]
110 | for field in summary_fields:
111 | if field not in result["summary"]:
112 | raise ValueError(f"汇总信息缺少必要字段: {field}")
113 |
114 | return True
115 |
116 |
--------------------------------------------------------------------------------
/apps/agents/generator.py:
--------------------------------------------------------------------------------
1 | from typing import Dict, Any, List, Optional
2 | import json
3 | from langchain_core.messages import SystemMessage, HumanMessage
4 | from ..llm.base import BaseLLMService
5 | from ..knowledge.service import KnowledgeService
6 | from .prompts import TestCaseGeneratorPrompt
7 | from utils.logger_manager import get_logger
8 | import re
9 | class TestCaseGeneratorAgent:
10 | """测试用例生成Agent"""
11 |
12 | def __init__(self, llm_service: BaseLLMService, knowledge_service: KnowledgeService, case_design_methods: List[str], case_categories: List[str], case_count: int = 10):
13 | self.llm_service = llm_service
14 | self.case_design_methods = case_design_methods
15 | self.case_categories = case_categories
16 | self.case_count = case_count
17 | self.knowledge_service = knowledge_service
18 | self.prompt = TestCaseGeneratorPrompt()
19 | self.logger = get_logger(self.__class__.__name__) # 添加logger
20 |
21 | def generate(self, input_text: str, input_type: str = "requirement") -> List[Dict[str, Any]]:
22 | """生成测试用例"""
23 | self.logger.info(f"开始生成测试用例,进入生成测试用例的TestCaseGeneratorAgent")
24 | # 确定输入类型描述
25 | input_type_desc = "需求描述" if input_type == "requirement" else "代码片段"
26 |
27 | # 获取知识上下文
28 | knowledge_context = self._get_knowledge_context(input_text)
29 | self.logger.info(f"获取到知识库上下文: \n{'='*50}\n{knowledge_context}\n{'='*50}")
30 |
31 | # 处理设计方法和测试类型
32 | case_design_methods = ",".join(self.case_design_methods) if self.case_design_methods else ""
33 | case_categories = ",".join(self.case_categories) if self.case_categories else ""
34 |
35 | # 使用新的 format_messages 方法获取消息列表
36 | messages = self.prompt.format_messages(
37 | requirements=input_text,
38 | case_design_methods=case_design_methods,
39 | case_categories=case_categories,
40 | case_count=self.case_count,
41 | knowledge_context=knowledge_context
42 | )
43 | self.logger.info(f"构建后大模型提示词+用户需求消息: \n{'='*50}\n{messages}\n{'='*50}")
44 |
45 | # 调用LLM服务
46 | try:
47 | response = self.llm_service.invoke(messages)
48 | result = response.content
49 | self.logger.info(f"LLM原始响应: \n{'='*50}\n{result}\n{'='*50}")
50 |
51 | # 尝试提取JSON部分
52 | json_str = self._extract_json_from_response(result)
53 | if not json_str:
54 | raise ValueError("无法从响应中提取有效的JSON数据")
55 |
56 | # 尝试解析JSON
57 | test_cases = json.loads(json_str)
58 | self.logger.info(f"_validate_test_cases处理前的用例个数: {len(test_cases)}")
59 |
60 | valid_test_cases = self._validate_test_cases(test_cases)
61 | return valid_test_cases
62 |
63 | except Exception as e:
64 | raise ValueError(f"无法解析生成的测试用例: {str(e)}\n原始响应: {result}")
65 |
66 | def _get_knowledge_context(self, input_text: str) -> str:
67 | """获取相关知识上下文"""
68 | try:
69 | # 暂时返回空字符串，直到KnowledgeService实现完成
70 | # return ""
71 | knowledge = self.knowledge_service.search_relevant_knowledge(input_text)
72 | if knowledge:
73 | return f"{knowledge}"
74 | except Exception as e:
75 | self.logger.warning(f"获取知识上下文失败: {str(e)}")
76 | return ""
77 |
78 | def _validate_test_cases(self, test_cases: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
79 | """验证并修复测试用例格式
80 |
81 | Args:
82 | test_cases: 原始测试用例列表
83 |
84 | Returns:
85 | 验证并修复后的测试用例列表
86 | """
87 | valid_test_cases = []
88 | required_fields = {"description", "test_steps", "expected_results"}
89 |
90 | for i, test_case in enumerate(test_cases):
91 | try:
92 | # 如果不是字典格式，跳过这个测试用例
93 | if not isinstance(test_case, dict):
94 | self.logger.warning(f"测试用例 #{i+1} 不是字典格式，已跳过")
95 | continue
96 |
97 | # 检查必要字段是否存在
98 | missing_fields = required_fields - set(test_case.keys())
99 | if missing_fields:
100 | self.logger.warning(f"测试用例 #{i+1} 缺少必要字段: {missing_fields}，已跳过")
101 | continue
102 |
103 | # 验证并修复字段格式
104 | # 1. description必须是字符串
105 | if not isinstance(test_case['description'], str):
106 | self.logger.warning(f"测试用例 #{i+1} 的description不是字符串格式，已跳过")
107 | continue
108 |
109 | # 2. test_steps必须是列表
110 | if not isinstance(test_case['test_steps'], list):
111 | self.logger.warning(f"测试用例 #{i+1} 的test_steps格式无法修复，已跳过")
112 | continue
113 |
114 | # 3. expected_results必须是列表
115 | if not isinstance(test_case['expected_results'], list):
116 | self.logger.warning(f"测试用例 #{i+1} 的expected_results格式无法修复，已跳过")
117 | continue
118 |
119 | # 确保所有字段都不为空
120 | if not test_case['description'].strip():
121 | self.logger.warning(f"测试用例 #{i+1} 的description为空，已跳过")
122 | continue
123 |
124 | if not test_case['test_steps']:
125 | self.logger.warning(f"测试用例 #{i+1} 的test_steps为空，已跳过")
126 | continue
127 |
128 | if not test_case['expected_results']:
129 | self.logger.warning(f"测试用例 #{i+1} 的expected_results为空，已跳过")
130 | continue
131 | # 通过所有验证，添加到有效列表
132 | valid_test_cases.append(test_case)
133 |
134 | except Exception as e:
135 | self.logger.warning(f"处理测试用例 #{i+1} 时出错: {str(e)}，已跳过")
136 | continue
137 |
138 | if not valid_test_cases:
139 | raise ValueError("没有找到任何合法的测试用例")
140 |
141 | self.logger.info(f"共处理 {len(test_cases)} 个测试用例，"
142 | f"其中 {len(valid_test_cases)} 个合法")
143 |
144 | return valid_test_cases
145 |
146 | def _extract_json_from_response(self, response: str) -> str:
147 | """从响应中提取JSON部分并进行基础修复
148 |
149 | Args:
150 | response: 原始响应字符串
151 |
152 | Returns:
153 | 修复后的JSON字符串
154 | """
155 | # 使用正则表达式提取JSON字符串
156 | result = ""
157 | right_format_pattern = r'^\[([\s\S]*)\]$'
158 | match = re.search(right_format_pattern, response)
159 | if match:
160 | result = match.group(0) # 使用group(0)返回完整匹配，包含方括号
161 | else:
162 | #从字符串中找到最后一个出现},的位置，然后取},前面的内容,并补全]和json结束标记```
163 | last_comma_index = response.rfind('},')
164 | if last_comma_index != -1:
165 | result = response[:last_comma_index+1] + ']'
166 | # self.logger.info(f"_extract_json_from_response函数处理结果: \n{'='*50}\n{result}\n{'='*50}")
167 | return result
168 |
169 |
170 |
171 |
--------------------------------------------------------------------------------
/apps/agents/prompts.py:
--------------------------------------------------------------------------------
1 | from pathlib import Path
2 | import yaml
3 | from typing import Dict, Any
4 | from langchain.prompts import ChatPromptTemplate
5 | from langchain.prompts.chat import SystemMessagePromptTemplate, HumanMessagePromptTemplate
6 |
7 | class PromptTemplateManager:
8 | """提示词模板管理器"""
9 |
10 | def __init__(self):
11 | """初始化，加载配置文件"""
12 | config_path = Path(__file__).parent / "prompts_config.yaml"
13 | with open(config_path, "r", encoding="utf-8") as f:
14 | self.config = yaml.safe_load(f)
15 |
16 | def get_test_case_generator_prompt(self) -> ChatPromptTemplate:
17 | """获取测试用例生成的提示词模板"""
18 | config = self.config['test_case_generator']
19 |
20 | # 准备系统消息的变量并格式化模板
21 | system_vars = {
22 | 'role': config['role'],
23 | 'capabilities': config['capabilities'],
24 | 'test_methods': ', '.join(config['test_methods']),
25 | 'test_types': ', '.join(config['test_types'])
26 | }
27 |
28 | # 创建系统消息模板
29 | system_message_prompt = SystemMessagePromptTemplate.from_template(
30 | config['system_template'].format(**system_vars) # 直接格式化模板
31 | )
32 |
33 | # 创建人类消息模板
34 | human_message_prompt = HumanMessagePromptTemplate.from_template(
35 | config['human_template']
36 | )
37 |
38 | # 组合成聊天提示词模板
39 | return ChatPromptTemplate.from_messages([
40 | system_message_prompt,
41 | human_message_prompt
42 | ])
43 |
44 | def get_test_case_reviewer_prompt(self) -> ChatPromptTemplate:
45 | """获取测试用例评审的提示词模板"""
46 | config = self.config['test_case_reviewer']
47 |
48 | # 准备系统消息的变量并格式化模板
49 | system_vars = {
50 | 'role': config['role'],
51 | 'evaluation_aspects': ', '.join(config['evaluation_aspects'])
52 | }
53 |
54 | # 创建系统消息模板
55 | system_message_prompt = SystemMessagePromptTemplate.from_template(
56 | config['system_template'].format(**system_vars) # 直接格式化模板
57 | )
58 |
59 | # 准备人类消息的变量
60 | human_vars = {
61 | 'review_points': '\n'.join(f"- {point}" for point in config['review_points'])
62 | }
63 |
64 | # 创建人类消息模板 - 不要在这里格式化 test_case
65 | human_message_prompt = HumanMessagePromptTemplate.from_template(
66 | config['human_template']
67 | )
68 |
69 | # 组合成聊天提示词模板
70 | return ChatPromptTemplate.from_messages([
71 | system_message_prompt,
72 | human_message_prompt
73 | ])
74 |
75 | def get_prd_analyser_prompt(self) -> ChatPromptTemplate:
76 | """获取PRD分析的提示词模板"""
77 | config = self.config['prd_analyser']
78 |
79 | # 准备系统消息的变量并格式化模板
80 | system_vars = {
81 | 'role': config['role'],
82 | 'capabilities': config['capabilities'],
83 | 'analysis_focus': ', '.join(config['analysis_focus'])
84 | }
85 |
86 | # 创建系统消息模板
87 | system_message_prompt = SystemMessagePromptTemplate.from_template(
88 | config['system_template'].format(**system_vars) # 直接格式化模板
89 | )
90 |
91 | # 创建人类消息模板
92 | human_message_prompt = HumanMessagePromptTemplate.from_template(
93 | config['human_template']
94 | )
95 |
96 | # 组合成聊天提示词模板
97 | return ChatPromptTemplate.from_messages([
98 | system_message_prompt,
99 | human_message_prompt
100 | ])
101 |
102 | class TestCaseGeneratorPrompt:
103 | """测试用例生成提示词"""
104 |
105 | def __init__(self):
106 | self.prompt_manager = PromptTemplateManager()
107 | self.prompt_template = self.prompt_manager.get_test_case_generator_prompt()
108 |
109 | def format_messages(self, requirements: str, case_design_methods: str = "",
110 | case_categories: str = "", knowledge_context: str = "",case_count: int = 10) -> list:
111 | """格式化消息
112 |
113 | Args:
114 | requirements: 需求描述
115 | case_design_methods: 测试用例设计方法
116 | case_categories: 测试用例类型
117 | knowledge_context: 知识库上下文
118 | case_count: 生成用例条数
119 | Returns:
120 | 格式化后的消息列表
121 | """
122 | # 处理空值情况
123 | if not case_design_methods:
124 | case_design_methods = "所有适用的测试用例设计方法"
125 |
126 | if not case_categories:
127 | case_categories = "所有适用的测试类型"
128 |
129 | # 格式化知识上下文提示
130 | knowledge_prompt = (
131 | f"参考以下知识库内容：\n{knowledge_context}"
132 | if knowledge_context
133 | else "根据你的专业知识"
134 | )
135 |
136 | return self.prompt_template.format_messages(
137 | requirements=requirements,
138 | case_design_methods=case_design_methods,
139 | case_categories=case_categories,
140 | case_count=case_count,
141 | knowledge_context=knowledge_prompt
142 | )
143 |
144 | class TestCaseReviewerPrompt:
145 | """测试用例评审提示词"""
146 |
147 | def __init__(self):
148 | self.prompt_manager = PromptTemplateManager()
149 | self.prompt_template = self.prompt_manager.get_test_case_reviewer_prompt()
150 |
151 | def format_messages(self, test_case: Dict[str, Any]) -> list:
152 | """格式化消息
153 |
154 | Args:
155 | test_case: 测试用例数据
156 |
157 | Returns:
158 | 格式化后的消息列表
159 | """
160 | # 格式化测试用例数据为字符串
161 | test_case_str = (
162 | f"测试用例描述：\n{test_case.get('description', '')}\n\n"
163 | f"测试步骤：\n{test_case.get('test_steps', '')}\n\n"
164 | f"预期结果：\n{test_case.get('expected_results', '')}"
165 | )
166 |
167 | # 获取评审点列表
168 | review_points = '\n'.join(
169 | f"- {point}"
170 | for point in self.prompt_manager.config['test_case_reviewer']['review_points']
171 | )
172 |
173 | return self.prompt_template.format_messages(
174 | test_case=test_case_str,
175 | review_points=review_points
176 | )
177 |
178 | class PrdAnalyserPrompt:
179 | """PRD分析提示词"""
180 |
181 | def __init__(self):
182 | self.prompt_manager = PromptTemplateManager()
183 | self.prompt_template = self.prompt_manager.get_prd_analyser_prompt()
184 |
185 | def format_messages(self, markdown_content: str) -> list:
186 | """格式化消息
187 |
188 | Args:
189 | markdown_content: Markdown格式的PRD文档内容
190 |
191 | Returns:
192 | 格式化后的消息列表
193 | """
194 | return self.prompt_template.format_messages(
195 | markdown_content=markdown_content
196 | )
197 |
198 |
199 | # 使用示例
200 | if __name__ == "__main__":
201 | # 测试用例生成
202 | # generator = TestCaseGeneratorPrompt()
203 | # messages = generator.format_messages(
204 | # requirements="实现用户登录功能",
205 | # case_design_methods="等价类划分法",
206 | # case_categories="功能测试",
207 | # knowledge_context="用户登录需要验证用户名和密码"
208 | # )
209 | # print("Generator Messages:", messages)
210 |
211 | # # 测试用例评审
212 | # reviewer = TestCaseReviewerPrompt()
213 | # test_case = {
214 | # "description": "测试用户登录功能",
215 | # "test_steps": ["1. 输入用户名", "2. 输入密码", "3. 点击登录按钮"],
216 | # "expected_results": ["1. 显示输入框", "2. 密码显示为星号", "3. 登录成功"]
217 | # }
218 | # messages = reviewer.format_messages(test_case)
219 | # print("\nReviewer Messages:", messages)
220 |
221 | # PRD分析
222 | analyser = PrdAnalyserPrompt()
223 | prd_content = """
224 | # 用户登录功能
225 |
226 | ## 功能描述
227 | 允许用户通过用户名和密码登录系统。
228 |
229 | ## 详细需求
230 | 1. 用户需要输入用户名和密码
231 | 2. 系统验证用户名和密码的正确性
232 | 3. 登录成功后跳转到首页
233 | """
234 | messages = analyser.format_messages(prd_content)
235 | print("\nPRD Analyser Messages:", messages)
236 |
--------------------------------------------------------------------------------
/apps/agents/prompts_config.yaml:
--------------------------------------------------------------------------------
1 | # 通用配置
2 | common:
3 | output_format:
4 | json_schema: true
5 | encoding: "utf-8"
6 |
7 | test_case_generator:
8 | role: "软件测试专家"
9 | capabilities:
10 | - "擅长根据需求或代码生成全面的测试用例"
11 | - "熟练掌握各种测试用例设计方法"
12 | - "熟悉各种测试用例类型"
13 |
14 | test_methods:
15 | - "等价类划分法"
16 | - "边界值分析法"
17 | - "判定表法"
18 | - "因果图法"
19 | - "正交分析法"
20 | - "场景法"
21 |
22 | test_types:
23 | - "功能测试"
24 | - "性能测试"
25 | - "兼容性测试"
26 | - "安全性测试"
27 |
28 | system_template: |
29 | 你是一位专业的{role}，{capabilities[0]}。
30 | 你应该{capabilities[1]}，包括：{test_methods}。
31 | 如果用户选择特定的测试用例设计方法，你必须根据用户指定的测试用例设计方法生成全面的测试用例。
32 | 你应该{capabilities[2]}，包括：{test_types}。
33 | 如果用户选择特定的测试用例类型，你必须根据用户指定的测试用例类型生成全面的测试用例。
34 | 你必须按照指定的格式返回测试用例，包括测试用例描述、测试步骤和预期结果。
35 | 除非用户明确要求，否则你应该尽可能多的生成测试用例。
36 |
37 | 重要提示：
38 | 1. 你必须严格按照JSON格式返回数据
39 | 2. 返回的JSON必须是一个数组，包含在 [] 中
40 | 3. 每个测试用例必须包含完整的字段
41 | 4. 不要在JSON数据之前或之后添加任何额外的解释文本
42 | 5. 确保所有字符串使用双引号，不要使用单引号
43 | 6. 确保数组元素之间使用逗号正确分隔
44 |
45 | human_template: |
46 | 请你{knowledge_context}，根据{case_design_methods}, 为{requirements}生成{case_count}条{case_categories}的测试用例。
47 | 生成的每条测试用例，必须包含以下内容：
48 | 1. 测试用例描述：简明扼要地描述测试的目的和内容
49 | 2. 测试步骤：详细的步骤列表，从1到n编号
50 | 3. 预期结果：每个步骤对应的预期结果，从1到n编号
51 |
52 | 请以JSON格式返回，格式如下：
53 | [
54 | {{
55 | "description": "测试用例描述",
56 | "test_steps": ["1. 步骤1", "2. 步骤2", ...],
57 | "expected_results": ["1. 结果1", "2. 结果2", ...]
58 | }}
59 | ]
60 |
61 | test_case_reviewer:
62 | role: "软件测试评审专家"
63 | evaluation_aspects:
64 | - "完整性"
65 | - "清晰度"
66 | - "可执行性"
67 | - "覆盖率"
68 |
69 | review_points:
70 | - "测试用例是否完整、清晰"
71 | - "测试步骤是否详细、可执行"
72 | - "预期结果是否明确、可验证"
73 | - "是否覆盖了所有功能点和边界条件"
74 | - "是否考虑了异常情况"
75 | - "是否符合测试最佳实践"
76 |
77 | system_template: |
78 | 你是一位专业的{role}，擅长评审测试用例的质量和完整性。
79 | 你的评审应该全面考虑测试用例的{evaluation_aspects}等方面。
80 | 你必须按照指定的格式返回评审结果。
81 |
82 | human_template: |
83 | 请对以下测试用例进行全面评审。
84 |
85 | {test_case}
86 |
87 | 评审应包括以下方面：
88 | {review_points}
89 |
90 | 评审结果一定要以JSON格式返回，格式如下：
91 | {{
92 | "score": 评分(1-10),
93 | "strengths": ["优点1", "优点2"],
94 | "weaknesses": ["缺点1", "缺点2"],
95 | "suggestions": ["建议1", "建议2"],
96 | "missing_scenarios": ["场景1", "场景2"],
97 | "recommendation": "通过/不通过",
98 | "comments": "总体评价"
99 | }}
100 |
101 | prd_analyser:
102 | role: "软件测试专家"
103 | capabilities:
104 | - "擅长从PRD/需求文档中提取测试点和测试场景"
105 | - "能够深入分析功能需求，挖掘潜在的测试场景"
106 | - "具备将业务需求转换为可测试项的能力"
107 |
108 | analysis_focus:
109 | - "功能需求点"
110 | - "业务规则"
111 | - "用户交互流程"
112 | - "系统边界条件"
113 | - "异常处理场景"
114 | - "性能相关要求"
115 |
116 | system_template: |
117 | 你是一位专业的{role}，{capabilities[0]}。
118 | 你应该{capabilities[1]}和{capabilities[2]}。
119 | 你的分析应该重点关注以下方面：{analysis_focus}。
120 | 你需要将PRD/需求文档中的每个相关功能点转化为测试点，并为每个测试点分析出可能的测试场景。测试场景详细描述中要将每个场景主要的操作步骤、预期结果表述清楚。
121 | 对于每个测试场景：
122 | 1. 操作步骤要清晰编号（如：1. xxx 2. xxx）
123 | 2. 预期结果要单独成行并标注（预期结果：xxx）
124 | 注意测试点和测试场景之间是一对多的关系，一个测试点可能对应多个测试场景。
125 |
126 | human_template: |
127 | 请分析以下Markdown格式的需求文档，提取所有测试点和对应的测试场景：
128 |
129 | ```
130 | {markdown_content}
131 | ```
132 |
133 | 请按照以下JSON格式返回分析结果：
134 | {{
135 | "test_points": [
136 | {{
137 | "id": "TP-001",
138 | "title": "测试点标题",
139 | "description": "测试点详细描述",
140 | "priority": "高/中/低",
141 | "scenarios": [
142 | {{
143 | "id": "TS-001-001",
144 | "title": "测试场景标题",
145 | "description": "测试场景详细描述",
146 | "test_type": "功能测试/性能测试/兼容性测试/安全性测试"
147 | }},
148 | {{
149 | "id": "TS-001-002",
150 | "title": "测试场景标题",
151 | "description": "测试场景详细描述",
152 | "test_type": "功能测试/性能测试/兼容性测试/安全性测试"
153 | }}
154 | ]
155 | }}
156 | ],
157 | "summary": {{
158 | "total_test_points": 10,
159 | "total_test_scenarios": 25,
160 | "high_priority_points": 5,
161 | "medium_priority_points": 3,
162 | "low_priority_points": 2
163 | }}
164 | }}
165 |
166 |
--------------------------------------------------------------------------------
/apps/agents/prompts_config_old.yaml:
--------------------------------------------------------------------------------
1 | test_case_generator:
2 | system_template: |
3 | 你是一位专业的软件测试专家，擅长根据需求或代码生成全面的测试用例。
4 | 你应该熟练掌握等价类划分法、边界值分析法、判定表法、因果图法、正交分析法、场景法等测试用例设计方法。
5 | 如果用户选择特定的测试用例设计方法，你必须根据用户指定的测试用例设计方法生成全面的测试用例。
6 | 你应该熟悉功能测试、性能测试、兼容性测试、安全性测试等测试用例类型之间的区别。
7 | 如果用户选择特定的测试用例类型，你必须根据用户指定的测试用例类型生成全面的测试用例。
8 | 你必须按照指定的格式返回测试用例，包括测试用例描述、测试步骤和预期结果。
9 |
10 | human_template: |
11 | 请你根据{case_design_methods}的测试用例设计方法, 为{requirements}生成{case_categories}类型的全面的测试用例。
12 | 在进行测试用例设计时,请你参考{knowledge_context}中的相关知识库内容。
13 |
14 |
15 | 请生成全面的测试用例，必须包含以下内容：
16 | 1. 测试用例描述：简明扼要地描述测试的目的和内容
17 | 2. 测试步骤:详细的步骤列表,从1到n编号
18 | 3. 预期结果:每个步骤对应的预期结果,从1到n编号
19 |
20 | 请以JSON格式返回,格式如下:
21 | [
22 | {{
23 | "description": "测试用例描述",
24 | "test_steps": [
25 | "1. 步骤1的描述",
26 | "2. 步骤2的描述",
27 | ...
28 | ],
29 | "expected_results": [
30 | "1. 预期结果1的描述",
31 | "2. 预期结果2的描述",
32 | ...
33 | ]
34 | }}
35 | ]
36 |
37 | 请确保测试步骤和预期结果的数量一致，并且每个步骤都有对应的预期结果。
38 |
39 | test_case_reviewer:
40 | system_template: |
41 | 你是一位专业的软件测试评审专家，擅长评审测试用例的质量和完整性。
42 | 你的评审应该全面考虑测试用例的完整性、清晰度、可执行性、覆盖率等方面。
43 | 你必须按照指定的格式返回评审结果。
44 |
45 | human_template: |
46 | 请对以下测试用例进行全面评审。
47 |
48 | {test_case}
49 |
50 | 请对测试用例进行全面评审，包括以下方面：
51 | 1. 测试用例是否完整、清晰
52 | 2. 测试步骤是否详细、可执行
53 | 3. 预期结果是否明确、可验证
54 | 4. 是否覆盖了所有功能点和边界条件
55 | 5. 是否考虑了异常情况
56 | 6. 是否符合测试最佳实践
57 |
58 | 请以JSON格式返回评审结果,格式如下:
59 | ```json
60 | {{
61 | "score": 评分(1-10),
62 | "strengths": ["优点1", "优点2", ...],
63 | "weaknesses": ["缺点1", "缺点2", ...],
64 | "suggestions": ["改进建议1", "改进建议2", ...],
65 | "missing_scenarios": ["缺失场景1", "缺失场景2", ...],
66 | "recommendation": "通过/不通过",
67 | "comments": "总体评价"
68 | }}
69 | ```
--------------------------------------------------------------------------------
/apps/agents/reviewer.py:
--------------------------------------------------------------------------------
1 | from typing import Dict, Any, List
2 | import json
3 | import logging
4 |
5 | from ..llm.base import BaseLLMService
6 | from ..knowledge.service import KnowledgeService
7 | from ..core.models import TestCase
8 | from .prompts import TestCaseReviewerPrompt
9 | from langchain_core.messages import SystemMessage, HumanMessage
10 | from utils.logger_manager import get_logger
11 |
12 |
13 |
14 | class TestCaseReviewerAgent:
15 | """测试用例评审Agent"""
16 |
17 | def __init__(self, llm_service: BaseLLMService, knowledge_service: KnowledgeService):
18 | self.llm_service = llm_service
19 | self.knowledge_service = knowledge_service
20 | self.prompt = TestCaseReviewerPrompt()
21 | self.logger = get_logger(self.__class__.__name__) # 添加logger
22 |
23 |
24 | def review(self, test_case: TestCase) -> Dict[str, Any]:
25 | """评审测试用例"""
26 | try:
27 | self.logger.info(f"待评审的测试用例数据为: \n{test_case}")
28 | # 构造测试用例数据字典
29 | test_case_dict = {
30 | "description": test_case.description,
31 | "test_steps": test_case.test_steps,
32 | "expected_results": test_case.expected_results
33 | }
34 |
35 | # 使用新的 format_messages 方法获取消息列表
36 | messages = self.prompt.format_messages(test_case_dict)
37 |
38 | self.logger.info(f"构建后的评审提示词: \n{'='*50}\n{messages}\n{'='*50}")
39 |
40 | # 调用LLM服务
41 | result = self.llm_service.invoke(messages) # 使用 invoke 方法替代 chat
42 |
43 | return result
44 |
45 | except Exception as e:
46 | self.logger.error(f"评审过程出错: {str(e)}", exc_info=True)
47 | raise Exception(f"评审失败: {str(e)}")
48 |
49 | def _format_prompt(self, test_case):
50 | """格式化提示词"""
51 | try:
52 | prompt = f"""请评审以下测试用例：
53 | 测试用例描述：
54 | {test_case.description}
55 | 测试步骤：
56 | {test_case.test_steps}
57 | 预期结果：
58 | {test_case.expected_results}
59 | """
60 | return prompt.strip()
61 |
62 | except Exception as e:
63 | self.logger.error(f"格式化提示词时出错: {str(e)}", exc_info=True)
64 | raise Exception(f"格式化提示词失败: {str(e)}")
65 |
--------------------------------------------------------------------------------
/apps/core/__init__.py:
--------------------------------------------------------------------------------
1 | # 空文件，使core成为一个Python包
--------------------------------------------------------------------------------
/apps/core/admin.py:
--------------------------------------------------------------------------------
1 | from django.contrib import admin
2 | from .models import TestCase, TestCaseReview, KnowledgeBase
3 |
4 | @admin.register(TestCase)
5 | class TestCaseAdmin(admin.ModelAdmin):
6 | list_display = ('title', 'status', 'created_by', 'created_at')
7 | list_filter = ('status', 'created_at')
8 | search_fields = ('title', 'description')
9 | readonly_fields = ('created_at', 'updated_at')
10 |
11 | @admin.register(TestCaseReview)
12 | class TestCaseReviewAdmin(admin.ModelAdmin):
13 | list_display = ('test_case', 'reviewer', 'review_date')
14 | list_filter = ('review_date',)
15 | search_fields = ('test_case__title', 'review_comments')
16 | readonly_fields = ('review_date',)
17 |
18 | @admin.register(KnowledgeBase)
19 | class KnowledgeBaseAdmin(admin.ModelAdmin):
20 | list_display = ('title', 'created_at')
21 | list_filter = ('created_at',)
22 | search_fields = ('title', 'content')
23 | readonly_fields = ('created_at', 'updated_at')
--------------------------------------------------------------------------------
/apps/core/forms.py:
--------------------------------------------------------------------------------
1 | from django import forms
2 | from .models import TestCase, KnowledgeBase
3 |
4 | class TestCaseForm(forms.ModelForm):
5 | """测试用例表单"""
6 | class Meta:
7 | model = TestCase
8 | fields = ['title', 'description', 'requirements', 'code_snippet',
9 | 'test_steps', 'expected_results']
10 | widgets = {
11 | 'description': forms.Textarea(attrs={'rows': 3}),
12 | 'requirements': forms.Textarea(attrs={'rows': 5}),
13 | 'code_snippet': forms.Textarea(attrs={'rows': 8, 'class': 'code-editor'}),
14 | 'test_steps': forms.Textarea(attrs={'rows': 8}),
15 | 'expected_results': forms.Textarea(attrs={'rows': 5}),
16 | }
17 |
18 | class TestCaseReviewForm(forms.Form):
19 | """测试用例评审表单"""
20 | comments = forms.CharField(
21 | widget=forms.Textarea(attrs={'rows': 5}),
22 | label="评审意见"
23 | )
24 | status = forms.ChoiceField(
25 | choices=[
26 | ('approved', '评审通过'),
27 | ('rejected', '评审未通过')
28 | ],
29 | label="评审结果"
30 | )
31 |
32 | class KnowledgeBaseForm(forms.ModelForm):
33 | """知识库条目表单"""
34 | class Meta:
35 | model = KnowledgeBase
36 | fields = ['title', 'content']
37 | widgets = {
38 | 'content': forms.Textarea(attrs={'rows': 10}),
39 | }
--------------------------------------------------------------------------------
/apps/core/migrations/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/MangoFisher/TestBrain/efd598cc84f51f357e5b0ec6833283b69d283649/apps/core/migrations/__init__.py
--------------------------------------------------------------------------------
/apps/core/milvus_helper.py:
--------------------------------------------------------------------------------
1 | """
2 | Milvus 向量数据库操作助手
3 | """
4 |
5 | import pandas as pd
6 | from pymilvus import connections, Collection, DataType, utility, FieldSchema, CollectionSchema
7 | from sentence_transformers import SentenceTransformer
8 | from apps.knowledge.vector_store import MilvusVectorStore
9 | from langchain.text_splitter import CharacterTextSplitter
10 | from unstructured.partition.xlsx import partition_xlsx
11 | # chunking策略basic适合表格结构文件, by_title适合文档结构文件,具体可翻阅https://docs.unstructured.io/open-source/core-functionality/chunking
12 | from unstructured.chunking.basic import chunk_elements
13 | from unstructured.chunking.title import chunk_by_title
14 | from utils.logger_manager import get_logger
15 | from unstructured.partition.auto import partition
16 | import os
17 |
18 |
19 | logger = get_logger(__name__)
20 |
21 | # 初始化嵌入模型（单例模式）
22 | _embedding_model = None
23 |
24 | def get_embedding_model():
25 | global _embedding_model
26 | if _embedding_model is None:
27 | _embedding_model = SentenceTransformer("BAAI/bge-m3", trust_remote_code=True)
28 | return _embedding_model
29 |
30 | # 初始化Milvus集合
31 | def init_milvus_collection(collection_name="vv_knowledge_collection"):
32 | """初始化Milvus集合"""
33 | logger.info("进入到init_milvus_collection方法")
34 | try:
35 | # 连接到Milvus服务器
36 | connections.connect(host="localhost", port="19530")
37 |
38 | # 检查集合是否存在
39 | if utility.has_collection(collection_name):
40 | return Collection(name=collection_name)
41 |
42 | # 如果集合不存在，创建新集合
43 | vector_store = MilvusVectorStore(collection_name)
44 | collection = vector_store.collection
45 |
46 | collection.load()
47 |
48 | return collection
49 |
50 | except Exception as e:
51 | raise Exception(f"初始化Milvus集合失败: {str(e)}")
52 |
53 | # 处理单个Excel文件
54 | def process_single_excel(file_path):
55 | """处理单个Excel文件"""
56 | try:
57 | elements = partition_xlsx(filename=file_path)
58 | chunks = chunk_elements(elements=elements, max_characters=500)
59 | except Exception as e:
60 | raise ValueError(f"Excel文件处理失败: {str(e)}")
61 | return chunks
62 |
63 | # 处理单个pdf文件
64 | def process_single_pdf(file_path):
65 | """处理单个pdf文件"""
66 | try:
67 | elements = partition(filename=file_path)
68 | chunks = chunk_by_title(
69 | elements,
70 | max_characters=500, # 每个块最多1500个字符
71 | combine_text_under_n_chars=200, # 合并小于300字符的块
72 | multipage_sections=True, # 允许部分跨页
73 | )
74 | except Exception as e:
75 | raise ValueError(f"Excel文件处理失败: {str(e)}")
76 | return chunks
77 |
78 |
79 | def process_singel_file(file_path):
80 | """处理单个文件, 返回文件分区、chunking后的chunks"""
81 | # NOTE: 如下是unstructured支持解析的文件类型，除此外的文件类型无法解析
82 | file_categories = {
83 | "CSV": [".csv"],
84 | "E-mail": [".eml", ".msg", ".p7s"],
85 | "EPUB": [".epub"],
86 | "Excel": [".xls", ".xlsx"],
87 | "HTML": [".html"],
88 | "Image": [".bmp", ".heic", ".jpeg", ".png", ".tiff"],
89 | "Markdown": [".md"],
90 | "Org Mode": [".org"],
91 | "Open Office": [".odt"],
92 | "PDF": [".pdf"],
93 | "Plain text": [".txt"],
94 | "PowerPoint": [".ppt", ".pptx"],
95 | "reStructured Text": [".rst"],
96 | "Rich Text": [".rtf"],
97 | "TSV": [".tsv"],
98 | "Word": [".doc", ".docx"],
99 | "XML": [".xml"]
100 | }
101 | file_type = os.path.splitext(file_path)[1]
102 | for _, types in file_categories.items():
103 | if file_type in types:
104 | #FIXME: 目前是自动判断文件类型，并根据文件类型使用对应的文件类型分区函数的默认参数，如果想更特性化的处理某一种文件类型，需要使用指定的文件分区函数
105 | logger.info(f"开始解析文件: {file_path}")
106 | try:
107 | if file_type in [".xlsx", ".xls"]:
108 | chunks = process_single_excel(file_path)
109 | elif file_type in [".pdf"]:
110 | chunks = process_single_pdf(file_path)
111 | else:
112 | elements = partition(filename=file_path)
113 | chunks = chunk_by_title(elements=elements, max_characters=500)
114 | logger.info(f"文件调用unstructured库分区、chunking成功")
115 | return chunks
116 | except Exception as e:
117 | logger.error(f"文件调用unstructured库分区、chunking失败: {str(e)}")
118 | return None
119 | raise ValueError(f"不支持的文件类型: {file_type}")
120 |
121 |
122 |
123 |
--------------------------------------------------------------------------------
/apps/core/models.py:
--------------------------------------------------------------------------------
1 | from django.db import models
2 | from django.contrib.auth.models import User
3 |
4 | class TestCase(models.Model):
5 | """测试用例模型"""
6 | STATUS_CHOICES = [
7 | ('pending', '待评审'),
8 | ('approved', '评审通过'),
9 | ('rejected', '评审未通过'),
10 | ]
11 |
12 | BU_CHOICES = [
13 | ('education', '教育'),
14 | ('user_center', '用户中心'),
15 | ('collaboration', '协同'),
16 | ('im', 'IM'),
17 | ('workspace', '工作台'),
18 | ('recruitment', '招聘'),
19 | ('work_management', '工作管理'),
20 | ('ai_application', 'AI 应用'),
21 | ('operation_platform', '运营平台'),
22 | ]
23 |
24 | PRIORITY_CHOICES = [
25 | ('p0', 'P0'),
26 | ('p1', 'P1'),
27 | ('p2', 'P2'),
28 | ('p3', 'P3'),
29 | ]
30 |
31 | title = models.CharField(max_length=200, verbose_name="测试用例标题")
32 | description = models.TextField(verbose_name="测试用例描述")
33 | requirements = models.TextField(verbose_name="需求描述", blank=True)
34 | code_snippet = models.TextField(verbose_name="代码片段", blank=True)
35 | test_steps = models.TextField(verbose_name="测试步骤")
36 | expected_results = models.TextField(verbose_name="预期结果")
37 | actual_results = models.TextField(verbose_name="实际结果", blank=True)
38 | status = models.CharField(
39 | max_length=20,
40 | choices=STATUS_CHOICES,
41 | default='pending',
42 | verbose_name="评审状态"
43 | )
44 | created_by = models.ForeignKey(
45 | User,
46 | on_delete=models.CASCADE,
47 | related_name='created_testcases',
48 | verbose_name="创建者",
49 | null=True,
50 | blank=True
51 | )
52 |
53 | created_at = models.DateTimeField(auto_now_add=True, verbose_name="创建时间")
54 | updated_at = models.DateTimeField(auto_now=True, verbose_name="更新时间")
55 | llm_provider = models.CharField(max_length=50, null=True, blank=True)
56 | bu = models.CharField(max_length=50, choices=BU_CHOICES, blank=True, verbose_name='BU')
57 | feature = models.CharField(max_length=100, blank=True, verbose_name='Feature')
58 | priority = models.CharField(max_length=2, choices=PRIORITY_CHOICES, blank=True, verbose_name='Priority')
59 |
60 | def __str__(self):
61 | return (
62 | f"用例描述：\n{self.description}\n\n"
63 | f"测试步骤：\n{self.test_steps}\n\n"
64 | f"预期结果：\n{self.expected_results}\n"
65 | )
66 |
67 | class Meta:
68 | verbose_name = "测试用例"
69 | verbose_name_plural = "测试用例"
70 |
71 | class TestCaseReview(models.Model):
72 | """测试用例评审记录"""
73 | test_case = models.ForeignKey(
74 | TestCase,
75 | on_delete=models.CASCADE,
76 | related_name='reviews',
77 | verbose_name="测试用例"
78 | )
79 | reviewer = models.ForeignKey(
80 | User,
81 | on_delete=models.CASCADE,
82 | related_name='reviews',
83 | verbose_name="评审人"
84 | )
85 | review_comments = models.TextField(verbose_name="评审意见")
86 | review_date = models.DateTimeField(auto_now_add=True, verbose_name="评审时间")
87 |
88 | def __str__(self):
89 | return f"Review for {self.test_case.title}"
90 |
91 | class Meta:
92 | verbose_name = "测试用例评审"
93 | verbose_name_plural = "测试用例评审"
94 |
95 | class KnowledgeBase(models.Model):
96 | """知识库条目"""
97 | title = models.CharField(max_length=200, verbose_name="知识条目标题")
98 | content = models.TextField(verbose_name="知识内容")
99 | vector_id = models.CharField(max_length=100, blank=True, verbose_name="向量ID")
100 | created_at = models.DateTimeField(auto_now_add=True, verbose_name="创建时间")
101 | updated_at = models.DateTimeField(auto_now=True, verbose_name="更新时间")
102 |
103 | def __str__(self):
104 | return self.title
105 |
106 | class Meta:
107 | verbose_name = "知识库"
108 | verbose_name_plural = "知识库"
--------------------------------------------------------------------------------
/apps/core/urls.py:
--------------------------------------------------------------------------------
1 | from django.urls import path
2 | from . import views
3 |
4 | urlpatterns = [
5 | # 页面路由
6 | path('', views.index, name='index'),
7 | path('generate/', views.generate, name='generate'),
8 | path('review/', views.review_view, name='review'),
9 | path('knowledge/', views.knowledge_view, name='knowledge'),
10 | path('case-review-detail/', views.case_review_detail, name='case_review_detail'),
11 |
12 | #知识库文件上传页面
13 | path('upload/', views.upload_single_file, name='upload_single_file'),
14 | #PRD分析页面
15 | path('analyser/', views.prd_analyser, name='prd_analyser'),
16 |
17 | # API路由
18 | path('api/copy-test-cases/', views.copy_test_cases, name='copy_test_cases'), #复制选中的用例集合
19 | path('api/export-test-cases-excel/', views.export_test_cases_excel, name='export_test_cases_excel'), #将用例集合导出到excel
20 |
21 |
22 | path('api/test-case/| 编号 | 218 |测试用例描述 | 219 |测试步骤 | 220 |预期结果 | 221 |
|---|---|---|---|
| ${index + 1} | 239 |${testCase.description || ''} | 240 |
241 | ${testSteps.map(step => ` ${step} `).join('')}
242 | |
243 |
244 | ${expectedResults.map(result => ` ${result} `).join('')}
245 | |
246 |
加载知识库...
102 |${item.content}
139 |${testCase.description}
361 |${review.comments}
425 | 426 |${review.suggestions}
428 | 429 |${item.content.substring(0, 150)}${item.content.length > 150 ? '...' : ''}
559 | 创建时间: ${new Date(item.created_at).toLocaleString()} 560 || 测试点标题 | 141 |测试点详细描述 | 142 |优先级 | 143 |测试场景详细描述 | 144 |测试类型 | 145 |
|---|
| 编号 | 100 |测试用例描述 | 101 |测试步骤 | 102 |预期结果 | 103 |
|---|---|---|---|
| {{ forloop.counter }} | 109 |{{ test_case.description }} | 110 |
111 | {% for step in test_case.test_steps %}
112 | {{ step }}
113 | {% endfor %}
114 | |
115 |
116 | {% for result in test_case.expected_results %}
117 | {{ result }}
118 | {% endfor %}
119 | |
120 |
总测试用例数
17 |待评审
25 |评审通过
33 |评审未通过
41 |加载知识库...
43 || 状态 | 43 |用例描述 | 44 |测试步骤 | 45 |预期结果 | 46 |操作 | 47 |
|---|---|---|---|---|
| 待评审 | 53 |{{ test_case.description }} | 54 |{{ test_case.test_steps }} | 55 |{{ test_case.expected_results }} | 56 |57 | 58 | | 59 |
|
91 |
92 |
93 |
94 |
95 | |
96 | 状态 | 97 |用例描述 | 98 |测试步骤 | 99 |预期结果 | 100 |-- | 101 |
|---|---|---|---|---|---|
|
107 |
108 |
110 |
111 |
112 | |
113 | 已通过 | 114 |{{ test_case.description }} | 115 |{{ test_case.test_steps }} | 116 |{{ test_case.expected_results }} | 117 |118 | {% if test_case.reviews.exists %} 119 | {{ test_case.reviews.last.review_comments }} 120 | {% endif %} 121 | | 122 |
|
161 |
162 |
163 |
164 |
165 | |
166 | 状态 | 167 |用例描述 | 168 |测试步骤 | 169 |预期结果 | 170 |评审意见 | 171 |操作 | 172 |
|---|---|---|---|---|---|---|
|
178 |
179 |
181 |
182 |
183 | |
184 | 未通过 | 185 |{{ test_case.description }} | 186 |{{ test_case.test_steps }} | 187 |{{ test_case.expected_results }} | 188 |189 | {% if test_case.reviews.exists %} 190 | {{ test_case.reviews.last.review_comments }} 191 | {% endif %} 192 | | 193 |194 | 195 | | 196 |