AI驱动的自动化测试：从用例生成到缺陷预测

class UnitTestGenerator:
    def __init__(self, llm):
        self.llm = llm
    
    def generate_tests(self, source_code, framework="pytest"):
        # 1. 分析源代码
        analysis = self._analyze_code(source_code)
        
        # 2. 生成测试策略
        strategy = self._generate_strategy(analysis)
        
        # 3. 生成测试用例
        test_cases = []
        for test_scenario in strategy:
            test = self.llm.generate(f"""
            为以下函数生成测试用例：
            
            函数代码：
            {source_code}
            
            测试场景：{test_scenario}
            框架：{framework}
            
            要求：
            - 使用有意义的测试名称
            - 包含Arrange-Act-Assert结构
            - 覆盖正常路径和异常路径
            - 使用参数化测试减少重复
            """)
            test_cases.append(test)
        
        # 4. 验证测试可运行
        validated = self._validate_tests(test_cases, source_code)
        
        return validated
    
    def _analyze_code(self, code):
        """分析代码结构和依赖"""
        return {
            "functions": extract_functions(code),
            "classes": extract_classes(code),
            "dependencies": extract_imports(code),
            "complexity": compute_complexity(code),
            "branches": extract_branches(code),
        }
    
    def _generate_strategy(self, analysis):
        """基于代码分析生成测试策略"""
        scenarios = []
        
        for func in analysis["functions"]:
            scenarios.extend([
                f"测试 {func.name} 的正常输入",
                f"测试 {func.name} 的边界值",
                f"测试 {func.name} 的异常输入",
                f"测试 {func.name} 的空值处理",
            ])
            
            # 复杂函数需要更多测试
            if func.complexity > 10:
                scenarios.append(f"测试 {func.name} 的复杂分支组合")
        
        return scenarios

class APITestGenerator:
    def __init__(self, llm):
        self.llm = llm
    
    def generate_from_openapi(self, spec):
        """从OpenAPI规范生成测试"""
        tests = []
        
        for endpoint in spec["paths"]:
            for method in spec["paths"][endpoint]:
                operation = spec["paths"][endpoint][method]
                
                # 生成正常请求测试
                tests.append(self._generate_happy_path(endpoint, method, operation))
                
                # 生成参数边界测试
                tests.extend(self._generate_boundary_tests(endpoint, method, operation))
                
                # 生成认证授权测试
                tests.extend(self._generate_auth_tests(endpoint, method, operation))
                
                # 生成并发测试
                if method in ["POST", "PUT", "DELETE"]:
                    tests.append(self._generate_concurrency_test(endpoint, method))
        
        return tests
    
    def _generate_boundary_tests(self, endpoint, method, operation):
        """生成边界值测试"""
        tests = []
        
        for param in operation.get("parameters", []):
            if param["in"] == "query":
                schema = param.get("schema", {})
                
                if schema.get("type") == "integer":
                    tests.append({
                        "name": f"测试 {param['name']} 最小值",
                        "request": {param["name"]: schema.get("minimum", 0)}
                    })
                    tests.append({
                        "name": f"测试 {param['name']} 最大值",
                        "request": {param["name"]: schema.get("maximum", 999999)}
                    })
                    tests.append({
                        "name": f"测试 {param['name']} 超范围",
                        "request": {param["name"]: schema.get("maximum", 999999) + 1},
                        "expected_status": 400
                    })
        
        return tests

class SmartTestSelector:
    def __init__(self):
        self.code_embedder = CodeEmbedder()
        self.test_index = TestIndex()
    
    def select(self, code_diff, all_tests):
        """选择与代码变更相关的测试"""
        # 1. 提取变更的代码块
        changed_blocks = extract_changed_blocks(code_diff)
        
        # 2. 编码变更代码
        changed_embeddings = [self.code_embedder.encode(block) for block in changed_blocks]
        
        # 3. 查找相关测试
        relevant_tests = set()
        for embedding in changed_embeddings:
            similar = self.test_index.search(embedding, top_k=10)
            for test in similar:
                relevant_tests.add(test["name"])
        
        # 4. 添加依赖链上的测试
        for test in list(relevant_tests):
            deps = self.test_index.get_dependencies(test)
            relevant_tests.update(deps)
        
        return list(relevant_tests)
    
    def update_index(self, test_name, test_code, covered_code):
        """更新测试索引"""
        embedding = self.code_embedder.encode(test_code)
        self.test_index.add({
            "name": test_name,
            "embedding": embedding,
            "covered_code": covered_code,
            "last_run": datetime.now(),
            "last_pass": True
})

class TestPrioritizer:
    def prioritize(self, tests, context):
        """根据多个因素排序测试优先级"""
        scored = []
        for test in tests:
            score = 0
            
            # 历史失败率（失败过的测试更可能再次失败）
            if test.historical_failure_rate > 0:
                score += test.historical_failure_rate * 40
            
            # 代码变更覆盖率
            if test.covers_changed_code:
                score += 30
            
            # 业务关键性
            if test.business_critical:
                score += 20
            
            # 执行速度（快速测试先跑）
            if test.avg_duration < 1.0:  # <1秒
                score += 10
            
            scored.append((test, score))
        
        scored.sort(key=lambda x: x[1], reverse=True)
        return [t for t, _ in scored]

class VisualRegressionTester:
    def __init__(self, vision_model):
        self.model = vision_model
    
    def compare(self, baseline, current):
        """比较UI截图的视觉差异"""
        # 1. 像素级对比（快速筛查）
        pixel_diff = self._pixel_diff(baseline, current)
        
        if pixel_diff < 0.01:  # 差异<1%
            return {"changed": False}
        
        # 2. AI语义对比（精确分析）
        analysis = self.model.analyze(
            images=[baseline, current],
            prompt="""比较这两个UI截图的差异：
            1. 布局是否有变化
            2. 文字内容是否不同
            3. 颜色/样式是否有变化
            4. 元素位置是否移动
            
            区分"有意义的变更"和"渲染差异"。
            """
        )
        
        return {
            "changed": analysis["meaningful_change"],
            "pixel_diff": pixel_diff,
            "semantic_diff": analysis["details"],
            "ignore": analysis["rendering_only"]  # 仅渲染差异可忽略
        }

class DefectPredictor:
    def __init__(self, llm):
        self.llm = llm
    
    def predict(self, code_change, history):
        """预测代码变更引入缺陷的风险"""
        risk_factors = []
        
        # 1. 复杂度分析
        complexity = compute_cyclomatic_complexity(code_change)
        if complexity > 15:
            risk_factors.append(f"高复杂度({complexity})")
        
        # 2. 变更规模
        lines_changed = count_changed_lines(code_change)
        if lines_changed > 100:
            risk_factors.append(f"大范围变更({lines_changed}行)")
        
        # 3. 历史缺陷率
        file_history = history.get(code_change.file_path, {})
        if file_history.get("defect_rate", 0) > 0.2:
            risk_factors.append("该文件历史缺陷率高")
        
        # 4. AI分析
        ai_analysis = self.llm.generate(f"""
        分析以下代码变更引入缺陷的风险：
        
        代码变更：
        {code_change.diff}
        
        风险因素：
        {risk_factors}
        
        识别：
        1. 潜在的bug模式
        2. 可能的竞态条件
        3. 异常处理缺失
        4. 边界条件遗漏
        """)
        
        risk_score = len(risk_factors) * 20 + parse_ai_risk(ai_analysis)
        
        return {
            "risk_level": "high" if risk_score > 60 else "medium" if risk_score > 30 else "low",
            "risk_factors": risk_factors,
            "ai_analysis": ai_analysis,
            "recommendations": self._generate_recommendations(risk_factors)
        }

class AITestReportGenerator:
    def generate(self, test_results, code_coverage, metrics):
        """生成智能测试报告"""
        report = self.llm.generate(f"""
        基于以下测试结果生成测试报告：
        
        测试结果：
        - 总数：{test_results.total}
        - 通过：{test_results.passed}
        - 失败：{test_results.failed}
        - 跳过：{test_results.skipped}
        
        代码覆盖率：
        - 行覆盖：{code_coverage.line}%
        - 分支覆盖：{code_coverage.branch}%
        - 函数覆盖：{code_coverage.function}%
        
        失败测试详情：
        {test_results.failures}
        
        请生成报告包含：
        1. 整体质量评估
        2. 失败测试的根因分析
        3. 覆盖率薄弱区域识别
        4. 风险评估和建议
        5. 趋势分析（与上次对比）
        """)
        
        return report