File size: 7,295 Bytes
d825c91
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
from fastapi import APIRouter, HTTPException, Depends
from typing import List, Dict, Any, Optional
from loguru import logger
from pydantic import BaseModel
import json

from services.test_service import test_service
from services.ai_service import ai_service

router = APIRouter()

class TestCase(BaseModel):
    id: str
    title: str
    preconditions: List[str]
    steps: List[str]
    expected_results: List[str]
    priority: str
    type: str
    requirement_id: str

class ExportRequest(BaseModel):
    test_cases: List[TestCase]
    target: str
    project_id: str
    section_id: Optional[str] = None

@router.post("/generate")
async def generate_test_cases(

    requirements: List[Dict[str, Any]],

    ai_provider: str = "openai",

    model: str = "gpt-3.5-turbo"

) -> List[Dict[str, Any]]:
    """

    Generate test cases from requirements.

    

    Parameters:

    - requirements: List of requirements

    - ai_provider: AI provider to use

    - model: Model to use

    """
    try:
        test_cases = await test_service.generate_test_cases(
            requirements=requirements,
            ai_service=ai_service
        )
        return test_cases
    except Exception as e:
        logger.error(f"Error generating test cases: {str(e)}")
        raise HTTPException(status_code=500, detail=str(e))

@router.post("/export")
async def export_test_cases(request: ExportRequest) -> Dict[str, Any]:
    """

    Export test cases to test management tool.

    

    Parameters:

    - request: Export request containing test cases and target information

    """
    try:
        if request.target == "testrail":
            if not request.section_id:
                raise HTTPException(
                    status_code=400,
                    detail="section_id is required for TestRail export"
                )
            results = await test_service.export_to_testrail(
                test_cases=request.test_cases,
                project_id=int(request.project_id),
                section_id=int(request.section_id)
            )
        elif request.target == "jira":
            results = await test_service.export_to_jira(
                test_cases=request.test_cases,
                project_key=request.project_id
            )
        elif request.target == "qtest":
            results = await test_service.export_to_qtest(
                test_cases=request.test_cases,
                project_id=int(request.project_id)
            )
        else:
            raise HTTPException(
                status_code=400,
                detail=f"Unsupported export target: {request.target}"
            )
        
        return {
            "status": "success",
            "results": results
        }
    except Exception as e:
        logger.error(f"Error exporting test cases: {str(e)}")
        raise HTTPException(status_code=500, detail=str(e))

@router.post("/validate")
async def validate_test_cases(

    test_cases: List[TestCase],

    requirements: List[Dict[str, Any]]

) -> Dict[str, Any]:
    """

    Validate test cases against requirements.

    

    Parameters:

    - test_cases: List of test cases

    - requirements: List of requirements

    """
    try:
        # Create requirement coverage matrix
        coverage = {}
        for req in requirements:
            coverage[req["id"]] = {
                "requirement": req,
                "test_cases": [],
                "covered": False
            }
        
        # Map test cases to requirements
        for test_case in test_cases:
            if test_case.requirement_id in coverage:
                coverage[test_case.requirement_id]["test_cases"].append(test_case)
                coverage[test_case.requirement_id]["covered"] = True
        
        # Calculate coverage metrics
        total_requirements = len(requirements)
        covered_requirements = sum(1 for req in coverage.values() if req["covered"])
        coverage_percentage = (covered_requirements / total_requirements) * 100
        
        # Identify uncovered requirements
        uncovered_requirements = [
            req["requirement"]
            for req in coverage.values()
            if not req["covered"]
        ]
        
        return {
            "status": "success",
            "coverage_percentage": coverage_percentage,
            "total_requirements": total_requirements,
            "covered_requirements": covered_requirements,
            "uncovered_requirements": uncovered_requirements,
            "coverage_matrix": coverage
        }
    except Exception as e:
        logger.error(f"Error validating test cases: {str(e)}")
        raise HTTPException(status_code=500, detail=str(e))

@router.post("/prioritize")
async def prioritize_test_cases(

    test_cases: List[TestCase],

    requirements: List[Dict[str, Any]]

) -> List[Dict[str, Any]]:
    """

    Prioritize test cases based on requirements and risk.

    

    Parameters:

    - test_cases: List of test cases

    - requirements: List of requirements

    """
    try:
        # Create risk assessment prompt
        prompt = f"""

        Analyze the following requirements and test cases to determine test case priority.

        Consider:

        1. Requirement priority

        2. Business impact

        3. Technical complexity

        4. Historical defect patterns

        

        Requirements:

        {json.dumps(requirements, indent=2)}

        

        Test Cases:

        {json.dumps([tc.dict() for tc in test_cases], indent=2)}

        

        For each test case, provide:

        1. Priority score (1-5)

        2. Risk level (High/Medium/Low)

        3. Justification

        """
        
        # Get AI assessment
        assessment = await ai_service.generate_response(prompt=prompt)
        
        # Parse and apply prioritization
        prioritized_cases = []
        for test_case in test_cases:
            # Find assessment for this test case
            case_assessment = _find_case_assessment(
                assessment["response"],
                test_case.id
            )
            
            prioritized_cases.append({
                "test_case": test_case,
                "priority_score": case_assessment["priority_score"],
                "risk_level": case_assessment["risk_level"],
                "justification": case_assessment["justification"]
            })
        
        # Sort by priority score
        prioritized_cases.sort(
            key=lambda x: x["priority_score"],
            reverse=True
        )
        
        return prioritized_cases
    except Exception as e:
        logger.error(f"Error prioritizing test cases: {str(e)}")
        raise HTTPException(status_code=500, detail=str(e))

def _find_case_assessment(assessment_text: str, case_id: str) -> Dict[str, Any]:
    """Extract assessment for a specific test case."""
    # This is a simplified implementation
    # In practice, you'd want more robust parsing
    return {
        "priority_score": 3,
        "risk_level": "Medium",
        "justification": "Default assessment"
    }