ai理解产品需求生成测试用例-deepseek

ai：把用例捡起来！把用例捡起来！

给大模型需求文档，让它完成设计用例，编写用例，包括功能用例、接口用例、自动化测试用例，自执行~最后发送至工作群中

直接使用deepseek即可

 

执行一下看看：

 调用ds分析需求：

 生成功能/接口用例：

 生成自动化用例：

 

 

 看一下自动生成的功能用例和接口用例：

# 为了验证用户登录功能，我们将使用 `pytest` 框架和 `requests` 库来进行 API 测试。以下是一个示例代码，展示了如何实现这个测试用例。
#
# ### 安装依赖
# 首先，确保你已经安装了 `pytest` 和 `requests` 库。如果没有安装，可以使用以下命令进行安装：
#
# ```bash
# pip install pytest requests
# ```
#
# ### 测试代码
#
# ```python
import pytest
import requests

# 定义登录API的URL
LOGIN_URL = "http://127.0.0.1:5000/login"

# 测试用例：验证用户登录功能
def test_user_login():
    # 定义测试数据
    username = "user1"
    password = "password1"
    
    # 构造请求体
    payload = {
        "username": username,
        "password": password
    }
    
    # 发送POST请求到登录API端点
    response = requests.post(LOGIN_URL, json=payload)
    
    # 验证响应状态码是否为200
    assert response.status_code == 200, f"Expected status code 200, but got {response.status_code}"
    
    # 解析API响应
    response_data = response.json()
    
    # 验证响应中是否包含预期的字段
    assert "token" in response_data, "Response does not contain 'token' field"
    assert "user_id" in response_data, "Response does not contain 'user_id' field"
    
    # 验证token和user_id是否有效
    assert isinstance(response_data["token"], str), "Token is not a string"
    assert isinstance(response_data["user_id"], int), "User ID is not an integer"

# 运行测试
if __name__ == "__main__":
    pytest.main()
# ```
#
# ### 代码说明
#
# 1. **LOGIN_URL**: 这是登录API的URL，你需要将其替换为实际的API端点。
#
# 2. **test_user_login**: 这是测试函数，使用 `pytest` 框架进行测试。
#
# 3. **payload**: 这是发送到API的请求体，包含用户名和密码。
#
# 4. **requests.post**: 发送POST请求到登录API端点。
#
# 5. **assert response.status_code == 200**: 验证响应状态码是否为200，表示请求成功。
#
# 6. **response.json()**: 解析API响应为JSON格式。
#
# 7. **assert "token" in response_data**: 验证响应中是否包含 `token` 字段。
#
# 8. **assert "user_id" in response_data**: 验证响应中是否包含 `user_id` 字段。
#
# 9. **assert isinstance(response_data["token"], str)**: 验证 `token` 是否为字符串类型。
#
# 10. **assert isinstance(response_data["user_id"], int)**: 验证 `user_id` 是否为整数类型。
#
# ### 运行测试
#
# 你可以通过以下命令运行测试：
#
# ```bash
# pytest test_login.py
# ```
#
# 如果所有断言都通过，测试将成功完成。如果有任何断言失败，`pytest` 将输出详细的错误信息，帮助你定位问题。

"""
自动化测试执行器
"""
import pytest
import os
import sys
from datetime import datetime
from typing import List, Dict
import json
from dotenv import load_dotenv

# 添加项目根目录到Python路径
current_dir = os.path.dirname(os.path.abspath(__file__))
project_root = os.path.abspath(os.path.join(current_dir, "../../../.."))
src_dir = os.path.join(project_root, "ai-test-generator", "src")
sys.path.insert(0, src_dir)

# 加载环境变量
env_path = os.path.join(project_root, "ai-test-generator", ".env")
print(f"正在加载环境变量文件: {env_path}")
load_dotenv(env_path)

try:
    from test_reporter import TestReporter, TestResult
except ImportError as e:
    print(f"错误：无法导入test_reporter模块。请确保项目结构正确。")
    print(f"当前目录: {current_dir}")
    print(f"项目根目录: {project_root}")
    print(f"src目录: {src_dir}")
    print(f"Python路径: {sys.path}")
    raise e

def run_tests(test_files: List[str] = None) -> bool:
    """
    运行测试用例并生成报告
    
    Args:
        test_files: 要运行的测试文件列表，如果为None则运行所有测试
        
    Returns:
        bool: 所有测试是否通过
    """
    print("\n开始执行测试...")
    
    # 初始化测试报告器
    reporter = TestReporter()
    
    # 如果没有指定测试文件，则运行所有测试
    if test_files is None:
        test_files = [f for f in os.listdir(os.path.dirname(__file__)) 
                     if f.endswith('_test.py') and f != '_automation.py']
        print(f"将运行所有测试文件: {test_files}")
    
    all_passed = True
    
    for test_file in test_files:
        test_path = os.path.join(os.path.dirname(__file__), test_file)
        test_id = os.path.splitext(test_file)[0]
        
        print(f"\n执行测试文件: {test_file}")
        
        # 记录测试执行
        start_time = datetime.now()
        try:
            # 运行测试
            result = pytest.main([test_path, '-v'])
            status = 'passed' if result == 0 else 'failed'
            error_msg = None if result == 0 else 'Test execution failed'
            if result != 0:
                all_passed = False
            print(f"测试执行结果: {status}")
        except Exception as e:
            status = 'error'
            error_msg = str(e)
            all_passed = False
            print(f"测试执行出错: {e}")
        
        duration = (datetime.now() - start_time).total_seconds()
        
        # 记录测试结果
        reporter.add_test_result(TestResult(
            test_id=test_id,
            test_name=test_file,
            test_type='api',
            status=status,
            duration=duration,
            error_message=error_msg,
            start_time=start_time.isoformat(),
            end_time=datetime.now().isoformat()
        ))
    
    # 生成并保存报告
    reports_dir = os.path.join(project_root, "ai-test-generator", "test_cases", "reports")
    reporter.save_report(reports_dir)
    
    # 发送钉钉通知
    print("\n准备发送测试报告...")
    reporter.send_dingtalk_notification()
    
    print(f"\n测试执行完成，{'全部通过' if all_passed else '存在失败'}")
    return all_passed

if __name__ == "__main__":
    # 获取命令行参数中的测试文件
    test_files = sys.argv[1:] if len(sys.argv) > 1 else None
    
    # 运行测试
    success = run_tests(test_files)
    
    # 设置退出码
    sys.exit(0 if success else 1)

metadata:
  id: FUNC_1__20250313_155452
  type: functional
  feature: 1._**用户登录功能**：
  generated_time: '2025-03-13T15:54:52.411287'
test_case:
  title: 用户登录功能测试
  description: 验证用户登录功能是否正常工作，确保用户能够通过正确的用户名和密码成功登录系统。
  test_type: functional
  prerequisites:
  - 系统已安装并运行
  - 用户已注册并拥有有效的用户名和密码
  steps:
  - 打开登录页面
  - 输入有效的用户名
  - 输入有效的密码
  - 点击登录按钮
  expected_results:
  - 登录页面成功加载
  - 用户名和密码输入框接受输入
  - 登录按钮可点击
  - 用户成功登录并跳转到主页
  test_data:
    username: testuser
    password: testpassword

本地简单写了个登录接口，用生成的用例跑一下，看看收集结果以及发送结果的功能

接口：

 改改用例里面的url和参数：

 

 

 

 report中的内容：

发送的wehook通知：

 代码：

main.py

import os
import sys
from test_generator import AITestGenerator
from test_case_manager import TestCaseManager
from dotenv import load_dotenv

def read_requirements():
    """从用户输入读取需求文档"""
    print("\n请输入需求文档（输入完成后请按Ctrl+D或Ctrl+Z结束）：")
    lines = []
    try:
        while True:
            line = input()
            lines.append(line)
    except (EOFError, KeyboardInterrupt):
        pass
    return "\n".join(lines)

def read_requirements_from_file(file_path):
    """从文件读取需求文档"""
    with open(file_path, 'r', encoding='utf-8') as f:
        return f.read()

def main():
    # 加载环境变量
    load_dotenv()
    
    # 初始化生成器和管理器
    generator = AITestGenerator()
    manager = TestCaseManager()
    
    # 解析命令行参数
    if len(sys.argv) < 2:
        print("用法: python main.py <command> [options]")
        print("命令:")
        print("  generate <requirements_file>  - 从需求文件生成测试用例")
        print("  generate                      - 从用户输入生成测试用例")
        print("  run [type] [feature]         - 执行测试用例")
        print("选项:")
        print("  type: functional 或 api")
        print("  feature: 特定功能名称")
        return
    
    command = sys.argv[1]
    
    if command == "generate":
        # 获取需求文档
        if len(sys.argv) > 2:
            # 从文件读取需求
            requirements = read_requirements_from_file(sys.argv[2])
        else:
            # 从用户输入读取需求
            requirements = read_requirements()
        
        if not requirements.strip():
            print("错误：需求文档不能为空")
            return
        
        # 分析需求
        print("\n正在分析需求文档...")
        features = generator.analyze_requirements(requirements)
        
        print("\n提取的功能点：")
        for i, feature in enumerate(features, 1):
            print(f"{i}. {feature}")
        
        # 为每个功能点生成测试用例
        test_types = ['functional', 'api', 'automation']
        for feature in features:
            feature_name = feature.strip().lower().replace(' ', '_')
            
            for test_type in test_types:
                print(f"\n正在生成 {test_type} 测试用例，功能点：{feature}")
                test_case = generator.generate_test_cases(feature, test_type)
                
                # 保存测试用例
                if test_type == 'functional':
                    # 保存为YAML文件
                    file_path = manager.save_functional_test(test_case.dict(), feature_name)
                    print(f"功能测试用例已保存到: {file_path}")
                    
                elif test_type == 'api':
                    # 保存为Python测试文件和JSON数据文件
                    case_path, data_path = manager.save_api_test(test_case.dict(), feature_name)
                    print(f"API测试用例已保存到: {case_path}")
                    print(f"API测试数据已保存到: {data_path}")
                    
                elif test_type == 'automation':
                    # 生成自动化测试代码
                    automation_code = generator.generate_automation_code(test_case)
                    # 保存自动化测试代码
                    file_path = os.path.join(manager.api_cases_dir, f"{feature_name}_automation.py")
                    with open(file_path, 'w', encoding='utf-8') as f:
                        f.write(automation_code)
                    print(f"自动化测试代码已保存到: {file_path}")
        
        print("\n所有测试用例生成完成！")
        print("\n您可以在以下目录找到生成的测试用例：")
        print(f"功能测试用例: {manager.functional_dir}")
        print(f"API测试用例: {manager.api_cases_dir}")
        print(f"API测试数据: {manager.api_data_dir}")
        
    elif command == "run":
        # 执行测试用例
        test_type = sys.argv[2] if len(sys.argv) > 2 else None
        feature = sys.argv[3] if len(sys.argv) > 3 else None
        
        print(f"\n开始执行测试{'（' + test_type + '）' if test_type else ''}")
        if feature:
            print(f"功能点: {feature}")
        
        success = manager.execute_tests(test_type, feature)
        
        print("\n测试执行完成！")
        print(f"测试{'全部通过' if success else '存在失败'}")
        print(f"详细报告已保存至: {manager.reports_dir}")
    
    else:
        print(f"未知命令: {command}")
        return

if __name__ == "__main__":
    main() 

test_case_manager.py

import os
import sys
from test_generator import AITestGenerator
from test_case_manager import TestCaseManager
from dotenv import load_dotenv

def read_requirements():
    """从用户输入读取需求文档"""
    print("\n请输入需求文档（输入完成后请按Ctrl+D或Ctrl+Z结束）：")
    lines = []
    try:
        while True:
            line = input()
            lines.append(line)
    except (EOFError, KeyboardInterrupt):
        pass
    return "\n".join(lines)

def read_requirements_from_file(file_path):
    """从文件读取需求文档"""
    with open(file_path, 'r', encoding='utf-8') as f:
        return f.read()

def main():
    # 加载环境变量
    load_dotenv()
    
    # 初始化生成器和管理器
    generator = AITestGenerator()
    manager = TestCaseManager()
    
    # 解析命令行参数
    if len(sys.argv) < 2:
        print("用法: python main.py <command> [options]")
        print("命令:")
        print("  generate <requirements_file>  - 从需求文件生成测试用例")
        print("  generate                      - 从用户输入生成测试用例")
        print("  run [type] [feature]         - 执行测试用例")
        print("选项:")
        print("  type: functional 或 api")
        print("  feature: 特定功能名称")
        return
    
    command = sys.argv[1]
    
    if command == "generate":
        # 获取需求文档
        if len(sys.argv) > 2:
            # 从文件读取需求
            requirements = read_requirements_from_file(sys.argv[2])
        else:
            # 从用户输入读取需求
            requirements = read_requirements()
        
        if not requirements.strip():
            print("错误：需求文档不能为空")
            return
        
        # 分析需求
        print("\n正在分析需求文档...")
        features = generator.analyze_requirements(requirements)
        
        print("\n提取的功能点：")
        for i, feature in enumerate(features, 1):
            print(f"{i}. {feature}")
        
        # 为每个功能点生成测试用例
        test_types = ['functional', 'api', 'automation']
        for feature in features:
            feature_name = feature.strip().lower().replace(' ', '_')
            
            for test_type in test_types:
                print(f"\n正在生成 {test_type} 测试用例，功能点：{feature}")
                test_case = generator.generate_test_cases(feature, test_type)
                
                # 保存测试用例
                if test_type == 'functional':
                    # 保存为YAML文件
                    file_path = manager.save_functional_test(test_case.dict(), feature_name)
                    print(f"功能测试用例已保存到: {file_path}")
                    
                elif test_type == 'api':
                    # 保存为Python测试文件和JSON数据文件
                    case_path, data_path = manager.save_api_test(test_case.dict(), feature_name)
                    print(f"API测试用例已保存到: {case_path}")
                    print(f"API测试数据已保存到: {data_path}")
                    
                elif test_type == 'automation':
                    # 生成自动化测试代码
                    automation_code = generator.generate_automation_code(test_case)
                    # 保存自动化测试代码
                    file_path = os.path.join(manager.api_cases_dir, f"{feature_name}_automation.py")
                    with open(file_path, 'w', encoding='utf-8') as f:
                        f.write(automation_code)
                    print(f"自动化测试代码已保存到: {file_path}")
        
        print("\n所有测试用例生成完成！")
        print("\n您可以在以下目录找到生成的测试用例：")
        print(f"功能测试用例: {manager.functional_dir}")
        print(f"API测试用例: {manager.api_cases_dir}")
        print(f"API测试数据: {manager.api_data_dir}")
        
    elif command == "run":
        # 执行测试用例
        test_type = sys.argv[2] if len(sys.argv) > 2 else None
        feature = sys.argv[3] if len(sys.argv) > 3 else None
        
        print(f"\n开始执行测试{'（' + test_type + '）' if test_type else ''}")
        if feature:
            print(f"功能点: {feature}")
        
        success = manager.execute_tests(test_type, feature)
        
        print("\n测试执行完成！")
        print(f"测试{'全部通过' if success else '存在失败'}")
        print(f"详细报告已保存至: {manager.reports_dir}")
    
    else:
        print(f"未知命令: {command}")
        return

if __name__ == "__main__":
    main() 

test_generator.py

import os
import sys
import time
import json
import re
from typing import List, Dict
import requests
import httpx
from dotenv import load_dotenv
from pydantic import BaseModel

class TestCase(BaseModel):
    """测试用例模型"""
    title: str
    description: str
    test_type: str  # 'functional', 'api', 'automation'
    prerequisites: List[str]
    steps: List[str]
    expected_results: List[str]
    test_data: Dict[str, str]

class AITestGenerator:
    def __init__(self):
        load_dotenv()
        self.api_key = os.getenv("DEEPSEEK_API_KEY")
        if not self.api_key:
            print("错误: 未找到DEEPSEEK_API_KEY环境变量。请确保.env文件中包含有效的API密钥。")
            sys.exit(1)
            
        self.url = "https://api.deepseek.com/chat/completions"
        self.headers = {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {self.api_key}"
        }
        print("成功初始化DeepSeek API配置")
        
    def _format_json_prompt(self, content: str) -> str:
        """格式化提示词，确保AI生成标准JSON格式响应"""
        return f"""请严格按照以下JSON格式生成响应：
{{
    "title": "测试用例标题",
    "description": "测试用例描述",
    "test_type": "api",
    "prerequisites": ["前置条件1", "前置条件2"],
    "steps": ["步骤1", "步骤2"],
    "expected_results": ["预期结果1", "预期结果2"],
    "test_data": {{
        "key1": "value1",
        "key2": "value2"
    }}
}}

请基于以下内容生成测试用例（请确保生成的是合法的JSON格式）：
{content}"""

    def _extract_json_from_text(self, text: str) -> str:
        """从文本中提取JSON部分"""
        # 查找第一个 { 和最后一个 } 之间的内容
        json_match = re.search(r'({[\s\S]*})', text)
        if json_match:
            return json_match.group(1)
        return text

    def _clean_json_string(self, json_str: str) -> str:
        """清理和修复常见的JSON格式问题"""
        # 移除可能导致解析错误的Unicode字符
        json_str = json_str.encode('utf-8', 'ignore').decode('utf-8')
        
        # 修复常见的格式问题
        json_str = re.sub(r'(?<!\\)"(\w+)"(?=:)', r'"\1"', json_str)  # 修复键的引号
        json_str = re.sub(r'(?<=: )"([^"]*?)(?<!\\)"(?=[,}\]])', r'"\1"', json_str)  # 修复值的引号
        json_str = re.sub(r',(\s*[}\]])', r'\1', json_str)  # 移除尾随逗号
        
        return json_str

    def _parse_ai_response(self, response: str) -> dict:
        """解析AI响应并转换为字典格式"""
        try:
            # 首先尝试直接解析
            return json.loads(response)
        except json.JSONDecodeError:
            print("直接解析JSON失败，尝试修复格式...")
            
            try:
                # 提取JSON部分
                json_str = self._extract_json_from_text(response)
                # 清理和修复JSON字符串
                cleaned_json = self._clean_json_string(json_str)
                # 再次尝试解析
                return json.loads(cleaned_json)
            except json.JSONDecodeError as e:
                print(f"JSON解析失败: {e}")
                print("原始响应:", response)
                
                # 构建一个基本的测试用例结构
                return self._create_fallback_test_case(response)

    def _create_fallback_test_case(self, raw_response: str) -> dict:
        """当JSON解析失败时创建基本的测试用例结构"""
        # 使用正则表达式提取可能的测试步骤
        steps = re.findall(r'\d+\.(.*?)(?=\d+\.|$)', raw_response, re.DOTALL)
        steps = [step.strip() for step in steps if step.strip()]
        
        # 尝试提取标题
        title_match = re.search(r'标题[：:](.*?)(?=\n|$)', raw_response)
        title = title_match.group(1).strip() if title_match else "未命名测试用例"
        
        # 尝试提取描述
        desc_match = re.search(r'描述[：:](.*?)(?=\n|$)', raw_response)
        description = desc_match.group(1).strip() if desc_match else raw_response[:100] + "..."
        
        return {
            "title": title,
            "description": description,
            "test_type": "api",
            "prerequisites": ["环境已正确配置", "服务正常运行"],
            "steps": steps if steps else ["请手动提取测试步骤"],
            "expected_results": ["请根据业务需求验证结果"],
            "test_data": {
                "note": "请根据实际情况补充测试数据"
            }
        }

    def analyze_requirements(self, requirements_text: str) -> List[str]:
        """分析需求文档，提取关键功能点"""
        try:
            print("正在分析需求文档...")
            data = {
                "model": "deepseek-chat",
                "messages": [
                    {"role": "system", "content": "你是一个专业的测试分析师，请帮助分析需求文档并提取关键功能点。"},
                    {"role": "user", "content": f"请分析以下需求文档并列出关键功能点：\n{requirements_text}"}
                ],
                "stream": False
            }
            
            response = requests.post(self.url, headers=self.headers, json=data)
            
            if response.status_code == 200:
                result = response.json()
                print("需求分析完成")
                return result['choices'][0]['message']['content'].split("\n")
            else:
                print(f"API请求失败，状态码: {response.status_code}")
                print(f"错误信息: {response.text}")
                return ["API请求失败"]
                
        except Exception as e:
            print(f"分析需求时出错: {e}")
            return ["分析需求时出错"]

    def generate_test_cases(self, feature: str, test_type: str) -> TestCase:
        """根据功能点生成测试用例"""
        prompt = self._create_test_case_prompt(feature, test_type)
        try:
            print(f"正在生成{test_type}测试用例...")
            data = {
                "model": "deepseek-chat",
                "messages": [
                    {"role": "system", "content": "你是一个专业的测试工程师，请根据功能点生成详细的测试用例。"},
                    {"role": "user", "content": self._format_json_prompt(prompt)}
                ],
                "stream": False
            }
            
            response = requests.post(self.url, headers=self.headers, json=data)
            
            if response.status_code == 200:
                result = response.json()
                print("测试用例生成完成")
                test_case_dict = self._parse_ai_response(result['choices'][0]['message']['content'])
                return TestCase(**test_case_dict)
            else:
                print(f"API请求失败，状态码: {response.status_code}")
                print(f"错误信息: {response.text}")
                raise Exception("API请求失败")
                
        except Exception as e:
            print(f"生成测试用例时出错: {e}")
            # 返回一个默认的测试用例
            return TestCase(
                title=f"生成失败 - {feature}",
                description="由于API连接问题，无法生成测试用例",
                test_type=test_type,
                prerequisites=["无"],
                steps=["无"],
                expected_results=["无"],
                test_data={}
            )

    def generate_automation_code(self, test_case: TestCase) -> str:
        """生成自动化测试代码"""
        prompt = f"""请为以下测试用例生成Python自动化测试代码：
        测试标题：{test_case.title}
        测试步骤：
        {chr(10).join(test_case.steps)}
        
        请使用pytest框架，并根据测试类型选择合适的工具（Selenium用于UI测试，requests用于API测试）。
        """
        
        try:
            print("正在生成自动化测试代码...")
            data = {
                "model": "deepseek-chat",
                "messages": [
                    {"role": "system", "content": "你是一个专业的自动化测试工程师，请生成Python自动化测试代码。"},
                    {"role": "user", "content": prompt}
                ],
                "stream": False
            }
            
            response = requests.post(self.url, headers=self.headers, json=data)
            
            if response.status_code == 200:
                result = response.json()
                print("自动化测试代码生成完成")
                return result['choices'][0]['message']['content']
            else:
                print(f"API请求失败，状态码: {response.status_code}")
                print(f"错误信息: {response.text}")
                raise Exception("API请求失败")
                
        except Exception as e:
            print(f"生成自动化测试代码时出错: {e}")
            return "由于API连接问题，无法生成自动化测试代码"

    def _create_test_case_prompt(self, feature: str, test_type: str) -> str:
        """创建生成测试用例的提示词"""
        if test_type == 'api':
            return f"""请为以下API功能点生成测试用例：
            功能：{feature}
            
            请包含以下信息：
            1. API接口名称和路径
            2. 请求方法（GET/POST等）
            3. 请求参数和格式
            4. 预期响应和状态码
            5. 异常情况测试
            6. 测试数据示例
            
            请确保生成的响应是合法的JSON格式。
            """
        else:
            return f"""请为以下功能点生成{test_type}测试用例：
            功能：{feature}
            
            请包含以下信息：
            1. 测试用例标题
            2. 测试描述
            3. 前置条件
            4. 测试步骤
            5. 预期结果
            6. 测试数据
            
            请确保生成的响应是合法的JSON格式。
            """ 

test_report.py

import os
import json
import requests
import time
import hmac
import hashlib
import base64
import urllib.parse
from datetime import datetime
from typing import Dict, List, Optional
from dataclasses import dataclass
from collections import defaultdict
from dotenv import load_dotenv

@dataclass
class TestResult:
    """Test execution result data structure"""
    test_id: str
    test_name: str
    test_type: str
    status: str  # 'passed', 'failed', 'skipped', 'error'
    duration: float
    error_message: Optional[str] = None
    start_time: Optional[str] = None
    end_time: Optional[str] = None

class TestReporter:
    """Test execution reporter that collects test results and sends notifications.
    
    This class provides functionality to:
    - Collect test execution results
    - Generate execution statistics
    - Send notifications via DingTalk webhook
    """
    
    def __init__(self, dingtalk_webhook: Optional[str] = None):
        """Initialize the test reporter.
        
        Args:
            dingtalk_webhook: DingTalk webhook URL for sending notifications
        """
        print("\n初始化测试报告器...")
        
        # 加载环境变量
        print("正在加载环境变量...")
        load_dotenv()
        
        # 获取钉钉webhook配置
        self.webhook_url = dingtalk_webhook or os.getenv("DINGTALK_WEBHOOK")
        self.secret = os.getenv("DINGTALK_SECRET")
        self.keyword = os.getenv("DINGTALK_KEYWORD")
        
        if not self.webhook_url:
            print("警告: 未配置钉钉Webhook URL，测试报告将不会发送到钉钉群")
            print("请在.env文件中设置DINGTALK_WEBHOOK环境变量")
        else:
            print(f"已配置钉钉Webhook URL: {self.webhook_url[:30]}...")
            if self.secret:
                print("已配置加签密钥")
            if self.keyword:
                print(f"已配置关键字: {self.keyword}")
        
        self.test_results: List[TestResult] = []
        self.start_time = datetime.now()
        print("测试报告器初始化完成\n")
    
    def _generate_sign(self) -> str:
        """Generate DingTalk signature.
        
        Returns:
            str: The signed URL with timestamp and sign parameters
        """
        timestamp = str(round(time.time() * 1000))
        secret_enc = self.secret.encode('utf-8')
        string_to_sign = '{}\n{}'.format(timestamp, self.secret)
        string_to_sign_enc = string_to_sign.encode('utf-8')
        hmac_code = hmac.new(secret_enc, string_to_sign_enc, digestmod=hashlib.sha256).digest()
        sign = urllib.parse.quote_plus(base64.b64encode(hmac_code))
        
        # 构建完整的URL
        if '?' in self.webhook_url:
            url = f"{self.webhook_url}&timestamp={timestamp}&sign={sign}"
        else:
            url = f"{self.webhook_url}?timestamp={timestamp}&sign={sign}"
        return url
    
    def add_test_result(self, result: TestResult):
        """Add a test execution result.
        
        Args:
            result: TestResult object containing execution details
        """
        self.test_results.append(result)
        print(f"添加测试结果: {result.test_name} - {result.status}")
    
    def generate_statistics(self) -> Dict:
        """Generate test execution statistics.
        
        Returns:
            Dictionary containing execution statistics
        """
        stats = {
            "total": len(self.test_results),
            "passed": 0,
            "failed": 0,
            "skipped": 0,
            "error": 0,
            "duration": 0.0,
            "by_type": defaultdict(lambda: {"total": 0, "passed": 0, "failed": 0, "skipped": 0, "error": 0})
        }
        
        for result in self.test_results:
            stats[result.status] += 1
            stats["duration"] += result.duration
            
            # Update type-specific statistics
            type_stats = stats["by_type"][result.test_type]
            type_stats["total"] += 1
            type_stats[result.status] += 1
        
        return dict(stats)
    
    def _generate_markdown_report(self) -> str:
        """Generate markdown formatted test execution report.
        
        Returns:
            Markdown formatted string containing the test report
        """
        stats = self.generate_statistics()
        end_time = datetime.now()
        duration = (end_time - self.start_time).total_seconds()
        
        # 添加关键字前缀
        keyword_prefix = f"【{self.keyword}】" if self.keyword else ""
        
        # Create markdown report
        report = [
            f"{keyword_prefix}## 测试执行报告",
            f"### 执行时间: {self.start_time.strftime('%Y-%m-%d %H:%M:%S')}",
            f"### 执行时长: {duration:.2f} 秒",
            "",
            "### 总体统计",
            f"- 总用例数: {stats['total']}",
            f"- 通过: {stats['passed']} ✅",
            f"- 失败: {stats['failed']} ❌",
            f"- 跳过: {stats['skipped']} ⚠️",
            f"- 错误: {stats['error']} 🚫",
            "",
            "### 分类统计"
        ]
        
        # Add type-specific statistics
        for test_type, type_stats in stats["by_type"].items():
            report.extend([
                f"#### {test_type}测试",
                f"- 总数: {type_stats['total']}",
                f"- 通过: {type_stats['passed']} ✅",
                f"- 失败: {type_stats['failed']} ❌",
                f"- 跳过: {type_stats['skipped']} ⚠️",
                f"- 错误: {type_stats['error']} 🚫"
            ])
        
        # Add failed test details
        failed_tests = [r for r in self.test_results if r.status in ('failed', 'error')]
        if failed_tests:
            report.extend([
                "",
                "### 失败用例详情"
            ])
            for test in failed_tests:
                report.extend([
                    f"#### {test.test_name}",
                    f"- ID: {test.test_id}",
                    f"- 类型: {test.test_type}",
                    f"- 状态: {test.status}",
                    f"- 错误信息: {test.error_message or '无'}"
                ])
        
        return "\n".join(report)
    
    def send_dingtalk_notification(self) -> bool:
        """Send test execution report to DingTalk group.
        
        Returns:
            bool: True if notification was sent successfully, False otherwise
        """
        print("\n准备发送钉钉通知...")
        
        if not self.webhook_url:
            print("错误: 未配置钉钉Webhook URL")
            return False
        
        try:
            markdown_content = self._generate_markdown_report()
            stats = self.generate_statistics()
            
            # 准备请求URL（处理加签）
            request_url = self._generate_sign() if self.secret else self.webhook_url
            
            # Prepare message
            message = {
                "msgtype": "markdown",
                "markdown": {
                    "title": "测试执行报告",
                    "text": markdown_content
                },
                "at": {
                    "isAtAll": stats["failed"] > 0 or stats["error"] > 0  # @所有人如果有失败用例
                }
            }
            
            print("正在发送钉钉通知...")
            print(f"消息内容预览:\n{markdown_content[:200]}...")
            
            # Send notification
            response = requests.post(
                request_url,
                json=message,
                headers={"Content-Type": "application/json"}
            )
            
            if response.status_code == 200:
                response_data = response.json()
                if response_data.get('errcode') == 0:
                    print("钉钉通知发送成功")
                    return True
                else:
                    print(f"钉钉通知发送失败: {response_data.get('errmsg')}")
                    return False
            else:
                print(f"钉钉通知发送失败: HTTP {response.status_code} - {response.text}")
                return False
                
        except Exception as e:
            print(f"发送钉钉通知时出错: {e}")
            return False
    
    def save_report(self, output_dir: str):
        """Save test execution report to files.
        
        Args:
            output_dir: Directory to save the report files
        """
        print(f"\n正在保存测试报告到目录: {output_dir}")
        os.makedirs(output_dir, exist_ok=True)
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        
        # Save markdown report
        markdown_path = os.path.join(output_dir, f"test_report_{timestamp}.md")
        with open(markdown_path, 'w', encoding='utf-8') as f:
            f.write(self._generate_markdown_report())
        
        # Save JSON statistics
        json_path = os.path.join(output_dir, f"test_stats_{timestamp}.json")
        with open(json_path, 'w', encoding='utf-8') as f:
            json.dump(self.generate_statistics(), f, ensure_ascii=False, indent=2)
        
        print(f"报告已保存至: {output_dir}") 

.env

# DeepSeek API配置
DEEPSEEK_API_KEY=xxxxxx

# 钉钉机器人配置
DINGTALK_WEBHOOK=xxxxxx

requirements.txt

deepseek-ai==0.0.1
requests>=2.32.3
httpx==0.24.1
pytest==7.4.3
selenium==4.15.2
python-dotenv==1.0.0
langchain==0.0.350
pydantic==2.5.2
black==23.11.0
pytest-html==4.1.1
PyYAML==6.0.1
jinja2==3.1.2