Update app.py

app.py

@@ -50,103 +50,173 @@ def call_openai_chat(messages, model="gpt-4o-mini", max_tokens=3000):
         return f"OpenAI API Error: {str(e)}"
 
 def parse_test_cases_to_dataframe(text_response):
-    """Enhanced parsing with better regex patterns"""
+    """Improved parsing that handles various response formats"""
     try:
         test_cases = []
         
-        # Enhanced regex patterns for better extraction
-        test_case_pattern = r'(?:Test Case|TC)\s*(?:ID|#)?\s*:?\s*([^\n]+)'
-        title_pattern = r'(?:Title|Test Case Title|Name)\s*:?\s*([^\n]+)'
-        precondition_pattern = r'(?:Precondition|Pre-condition|Prerequisites?)\s*:?\s*([^\n]+)'
-        steps_pattern = r'(?:Test Steps?|Steps|Procedure)\s*:?\s*((?:[^\n]*\n?)*?)(?=Expected|Priority|Test Case|$)'
-        expected_pattern = r'(?:Expected Result|Expected|Result)\s*:?\s*([^\n]+)'
-        priority_pattern = r'(?:Priority|Severity)\s*:?\s*([^\n]+)'
-        test_data_pattern = r'(?:Test Data|Data)\s*:?\s*([^\n]+)'
+        # First, try to split by common delimiters
+        # Look for patterns like "Test Case", "TC", numbers followed by periods, etc.
+        potential_blocks = []
         
-        # Split into test case blocks more accurately
-        blocks = re.split(r'\n\s*(?=(?:Test Case|TC)\s*(?:ID|#|\d+))', text_response, flags=re.IGNORECASE)
+        # Split by various patterns that might indicate new test cases
+        split_patterns = [
+            r'\n(?=Test Case[:\s#]*\d+)',
+            r'\n(?=TC[:\s#]*\d+)',
+            r'\n(?=\d+\.?\s*Test)',
+            r'\n(?=#{1,3}\s*Test)',
+            r'\n(?=\*\*Test Case)',
+            r'\n(?=## Test Case)',
+        ]
         
+        blocks = [text_response]  # Start with the whole text
+        
+        for pattern in split_patterns:
+            new_blocks = []
+            for block in blocks:
+                new_blocks.extend(re.split(pattern, block, flags=re.IGNORECASE | re.MULTILINE))
+            blocks = [b for b in new_blocks if len(b.strip()) > 20]
+            if len(blocks) > 1:  # If we found a good split, use it
+                break
+        
+        # If we still have only one block, try a more aggressive split
+        if len(blocks) <= 1:
+            lines = text_response.split('\n')
+            current_block = []
+            blocks = []
+            
+            for line in lines:
+                line = line.strip()
+                if not line:
+                    continue
+                    
+                # Check if this line starts a new test case
+                if (re.match(r'(test case|tc)\s*[:#]?\s*\d+', line.lower()) or
+                    re.match(r'\d+\.?\s*(test|scenario)', line.lower()) or
+                    re.match(r'#{1,3}\s*test', line.lower()) or
+                    '**Test Case' in line):
+                    
+                    if current_block:
+                        blocks.append('\n'.join(current_block))
+                        current_block = []
+                    current_block.append(line)
+                else:
+                    current_block.append(line)
+            
+            if current_block:
+                blocks.append('\n'.join(current_block))
+        
+        # Parse each block
         for i, block in enumerate(blocks):
-            if len(block.strip()) < 30:
+            if len(block.strip()) < 20:
                 continue
                 
+            # Extract information using multiple strategies
             test_case = {}
             
-            # Extract components with fallbacks
-            id_match = re.search(test_case_pattern, block, re.IGNORECASE)
-            test_case['Test_Case_ID'] = id_match.group(1).strip() if id_match else f"TC_{len(test_cases)+1:03d}"
+            # Strategy 1: Look for labeled fields
+            lines = [line.strip() for line in block.split('\n') if line.strip()]
             
-            title_match = re.search(title_pattern, block, re.IGNORECASE)
-            test_case['Title'] = title_match.group(1).strip() if title_match else f"Test Case {len(test_cases)+1}"
+            # Initialize with defaults
+            test_case['Test_Case_ID'] = f"TC_{len(test_cases)+1:03d}"
+            test_case['Title'] = f"Test Case {len(test_cases)+1}"
+            test_case['Preconditions'] = "N/A"
+            test_case['Test_Steps'] = ""
+            test_case['Expected_Results'] = ""
+            test_case['Priority'] = "Medium"
+            test_case['Test_Data'] = "N/A"
             
-            precond_match = re.search(precondition_pattern, block, re.IGNORECASE)
-            test_case['Preconditions'] = precond_match.group(1).strip() if precond_match else "N/A"
+            # Parse line by line for labeled content
+            current_field = None
+            steps_lines = []
             
-            steps_match = re.search(steps_pattern, block, re.IGNORECASE | re.DOTALL)
-            test_case['Test_Steps'] = steps_match.group(1).strip() if steps_match else "Steps not specified"
-            
-            expected_match = re.search(expected_pattern, block, re.IGNORECASE)
-            test_case['Expected_Results'] = expected_match.group(1).strip() if expected_match else "Expected result not specified"
+            for line in lines:
+                line_lower = line.lower()
+                
+                # Check for field labels
+                if any(label in line_lower for label in ['test case id', 'tc id', 'id:']):
+                    test_case['Test_Case_ID'] = re.sub(r'.*?[:\-]\s*', '', line).strip()
+                    current_field = None
+                    
+                elif any(label in line_lower for label in ['title:', 'test case title', 'name:']):
+                    test_case['Title'] = re.sub(r'.*?[:\-]\s*', '', line).strip()
+                    current_field = None
+                    
+                elif any(label in line_lower for label in ['precondition', 'prerequisite']):
+                    test_case['Preconditions'] = re.sub(r'.*?[:\-]\s*', '', line).strip()
+                    current_field = None
+                    
+                elif any(label in line_lower for label in ['test step', 'steps:', 'procedure']):
+                    current_field = 'steps'
+                    step_content = re.sub(r'.*?[:\-]\s*', '', line).strip()
+                    if step_content:
+                        steps_lines.append(step_content)
+                        
+                elif any(label in line_lower for label in ['expected result', 'expected:', 'result:']):
+                    test_case['Expected_Results'] = re.sub(r'.*?[:\-]\s*', '', line).strip()
+                    current_field = None
+                    
+                elif any(label in line_lower for label in ['priority:', 'severity:']):
+                    test_case['Priority'] = re.sub(r'.*?[:\-]\s*', '', line).strip()
+                    current_field = None
+                    
+                elif any(label in line_lower for label in ['test data:', 'data:']):
+                    test_case['Test_Data'] = re.sub(r'.*?[:\-]\s*', '', line).strip()
+                    current_field = None
+                    
+                else:
+                    # If we're in the middle of collecting steps, add this line
+                    if current_field == 'steps':
+                        steps_lines.append(line)
+                    elif not any(test_case.values()):  # If nothing has been set yet, this might be the title
+                        if len(line) > 5 and not line.startswith(('•', '-', '*', '1.', '2.')):
+                            test_case['Title'] = line[:100]
             
-            priority_match = re.search(priority_pattern, block, re.IGNORECASE)
-            test_case['Priority'] = priority_match.group(1).strip() if priority_match else "Medium"
+            # Combine steps
+            if steps_lines:
+                test_case['Test_Steps'] = '\n'.join(steps_lines)
             
-            data_match = re.search(test_data_pattern, block, re.IGNORECASE)
-            test_case['Test_Data'] = data_match.group(1).strip() if data_match else "N/A"
+            # Fallback: if we couldn't parse properly, use the first few lines
+            if (test_case['Title'] == f"Test Case {len(test_cases)+1}" and 
+                test_case['Test_Steps'] == "" and 
+                test_case['Expected_Results'] == ""):
+                
+                if len(lines) > 0:
+                    test_case['Title'] = lines[0][:100]
+                if len(lines) > 1:
+                    test_case['Test_Steps'] = '\n'.join(lines[1:min(len(lines), 4)])
+                if len(lines) > 4:
+                    test_case['Expected_Results'] = lines[-1][:200]
             
+            # Add metadata
             test_case['Created_Date'] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
             test_case['Status'] = "New"
             
             test_cases.append(test_case)
         
-        # Enhanced fallback parsing
+        # Final fallback - create from raw text
         if not test_cases:
-            lines = [line.strip() for line in text_response.split('\n') if line.strip()]
-            current_case = {}
-            
-            for line in lines:
-                if any(keyword in line.lower() for keyword in ['test case', 'tc', 'scenario']):
-                    if current_case:
-                        test_cases.append(current_case)
-                    current_case = {
-                        'Test_Case_ID': f"TC_{len(test_cases)+1:03d}",
-                        'Title': line[:100],
-                        'Preconditions': "N/A",
-                        'Test_Steps': "",
-                        'Expected_Results': "",
-                        'Priority': "Medium",
-                        'Test_Data': "N/A",
-                        'Created_Date': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                        'Status': "New"
-                    }
-                elif current_case:
-                    if not current_case.get('Test_Steps'):
-                        current_case['Test_Steps'] = line
-                    elif not current_case.get('Expected_Results'):
-                        current_case['Expected_Results'] = line
-            
-            if current_case:
-                test_cases.append(current_case)
+            test_cases.append({
+                'Test_Case_ID': 'TC_001',
+                'Title': 'Generated Test Case',
+                'Preconditions': 'N/A',
+                'Test_Steps': text_response[:500] + "..." if len(text_response) > 500 else text_response,
+                'Expected_Results': 'Review generated content',
+                'Priority': 'Medium',
+                'Test_Data': 'N/A',
+                'Created_Date': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                'Status': 'Needs Review'
+            })
         
-        return pd.DataFrame(test_cases) if test_cases else pd.DataFrame({
-            'Test_Case_ID': ['TC_001'],
-            'Title': ['Sample Test Case'],
-            'Preconditions': ['N/A'],
-            'Test_Steps': ['Parse failed - manual review needed'],
-            'Expected_Results': ['Manual review needed'],
-            'Priority': ['Medium'],
-            'Test_Data': ['N/A'],
-            'Created_Date': [datetime.now().strftime("%Y-%m-%d %H:%M:%S")],
-            'Status': ['New']
-        })
+        return pd.DataFrame(test_cases)
     
     except Exception as e:
+        # Error fallback
         return pd.DataFrame({
             'Test_Case_ID': ['TC_001'],
             'Title': ['Parsing Error'],
             'Preconditions': ['N/A'],
-            'Test_Steps': [f'Error: {str(e)}'],
-            'Expected_Results': ['Manual review needed'],
+            'Test_Steps': [f'Error parsing response: {str(e)}\n\nOriginal text: {text_response[:300]}...'],
+            'Expected_Results': ['Manual review required'],
             'Priority': ['High'],
             'Test_Data': ['N/A'],
             'Created_Date': [datetime.now().strftime("%Y-%m-%d %H:%M:%S")],
@@ -251,75 +321,84 @@ def generate_test_cases_from_text(requirements, test_types, priority_level):
     """Enhanced test case generation with more specific prompts"""
     
     enhanced_prompt = f"""
-    As an expert QA engineer, create comprehensive and detailed test cases for the following requirements:
-    
+    As an expert QA engineer, create comprehensive and detailed test cases for the following requirements.
+
     REQUIREMENTS:
     {requirements}
-    
+
     INSTRUCTIONS:
     - Generate {test_types} test scenarios
     - Focus on {priority_level} priority tests
-    - Follow standard test case format exactly
-    - Include both positive and negative scenarios
-    - Consider edge cases and boundary conditions
-    - Make test steps clear and actionable
-    
-    FORMAT EACH TEST CASE AS:
-    Test Case ID: TC_XXX
-    Test Case Title: [Clear, descriptive title]
-    Preconditions: [What must be true before testing]
+    - Use EXACTLY this format for each test case
+    - Generate 5-8 test cases with clear separation
+
+    FORMAT EACH TEST CASE EXACTLY AS SHOWN:
+
+    Test Case ID: TC_001
+    Title: Login with valid credentials
+    Preconditions: User has a valid account, application is accessible
     Test Steps: 
-    1. [Clear step-by-step instructions]
-    2. [Each step should be specific and actionable]
-    3. [Include test data where applicable]
-    Expected Results: [What should happen when test passes]
-    Priority: [High/Medium/Low]
-    Test Data: [Specific data needed for testing]
-    
-    Generate at least 5-8 comprehensive test cases covering different scenarios.
+    1. Navigate to login page
+    2. Enter valid username
+    3. Enter valid password
+    4. Click login button
+    Expected Results: User successfully logs in and redirects to dashboard
+    Priority: High
+    Test Data: username: testuser@example.com, password: Test123!
+
+    Test Case ID: TC_002
+    Title: Login with invalid credentials
+    Preconditions: Application is accessible
+    Test Steps: 
+    1. Navigate to login page
+    2. Enter invalid username
+    3. Enter invalid password
+    4. Click login button
+    Expected Results: Error message displayed, user remains on login page
+    Priority: High
+    Test Data: username: invalid@test.com, password: wrongpass
+
+    Now generate test cases for the given requirements following this EXACT format.
     """
     
     messages = [{"role": "user", "content": enhanced_prompt}]
     response = call_openai_chat(messages, max_tokens=4000)
     
     if "Error:" in response:
-        return response, None
+        return response, None, None
     
     df = parse_test_cases_to_dataframe(response)
     csv_path = create_download_csv(df, "generated_test_cases")
     
-    return response, csv_path
+    return response, df, csv_path
 
 def generate_test_cases_from_image(image, test_focus):
     """Enhanced image-based test case generation"""
     
+    if image is None:
+        return "Please upload an image first.", None, None
+    
     base64_image = encode_image(image)
     
     enhanced_prompt = f"""
-    As an expert QA engineer, analyze this requirements image/mockup/wireframe and create comprehensive test cases.
-    
+    As an expert QA engineer, analyze this UI/wireframe/mockup image and create test cases.
+
     FOCUS AREA: {test_focus}
-    
-    INSTRUCTIONS:
-    - Examine all UI elements, workflows, and user interactions visible
-    - Consider usability, functionality, and user experience aspects
-    - Generate test cases for different user scenarios
-    - Include accessibility and responsive design considerations
-    - Cover both happy path and error scenarios
-    
-    FORMAT EACH TEST CASE AS:
-    Test Case ID: TC_XXX
-    Test Case Title: [Clear, descriptive title]
+
+    Use EXACTLY this format for each test case:
+
+    Test Case ID: TC_001
+    Title: [Clear descriptive title]
     Preconditions: [Setup requirements]
     Test Steps: 
-    1. [Detailed step-by-step instructions]
-    2. [Include specific UI elements to interact with]
-    3. [Specify expected user actions]
-    Expected Results: [Expected behavior/outcome]
-    Priority: [High/Medium/Low based on business impact]
-    Test Data: [Required test data]
-    
-    Generate comprehensive test cases covering all visible functionality.
+    1. [Step 1]
+    2. [Step 2]
+    3. [Step 3]
+    Expected Results: [Expected outcome]
+    Priority: [High/Medium/Low]
+    Test Data: [Required data]
+
+    Generate 5-8 test cases covering all visible UI elements and user flows.
     """
     
     messages = [
@@ -335,12 +414,12 @@ def generate_test_cases_from_image(image, test_focus):
     response = call_openai_chat(messages, model="gpt-4o-mini", max_tokens=4000)
     
     if "Error:" in response:
-        return response, None
+        return response, None, None
     
     df = parse_test_cases_to_dataframe(response)
     csv_path = create_download_csv(df, "image_based_test_cases")
     
-    return response, csv_path
+    return response, df, csv_path
 
 def optimize_test_cases(existing_cases, focus_areas, optimization_goal):
     """Enhanced test case optimization"""
@@ -676,15 +755,25 @@ def create_gradio_interface():
                             with gr.Column():
                                 test_cases_output = gr.Textbox(
                                     label="Generated Test Cases",
-                                    lines=15,
-                                    max_lines=20
+                                    lines=10,
+                                    max_lines=15
                                 )
-                                csv_download = gr.File(label="Download CSV")
+                                
+                        # Add a separate row for the dataframe and download
+                        with gr.Row():
+                            test_cases_table = gr.Dataframe(
+                                label="📊 Test Cases Table",
+                                interactive=False,
+                                wrap=True
+                            )
+                        
+                        with gr.Row():
+                            csv_download = gr.File(label="📥 Download CSV")
                         
                         generate_btn.click(
                             fn=generate_test_cases_from_text,
                             inputs=[requirements_input, test_types, priority_level],
-                            outputs=[test_cases_output, csv_download]
+                            outputs=[test_cases_output, test_cases_table, csv_download]
                         )
                     
                     with gr.TabItem("Image Requirements"):
@@ -704,15 +793,25 @@ def create_gradio_interface():
                             with gr.Column():
                                 img_test_cases_output = gr.Textbox(
                                     label="Generated Test Cases",
-                                    lines=15,
-                                    max_lines=20
+                                    lines=10,
+                                    max_lines=15
                                 )
-                                img_csv_download = gr.File(label="Download CSV")
+                        
+                        # Add separate row for table and download
+                        with gr.Row():
+                            img_test_cases_table = gr.Dataframe(
+                                label="📊 Test Cases Table",
+                                interactive=False,
+                                wrap=True
+                            )
+                        
+                        with gr.Row():
+                            img_csv_download = gr.File(label="📥 Download CSV")
                         
                         generate_img_btn.click(
                             fn=generate_test_cases_from_image,
                             inputs=[image_input, test_focus],
-                            outputs=[img_test_cases_output, img_csv_download]
+                            outputs=[img_test_cases_output, img_test_cases_table, img_csv_download]
                         )
             
             # Test Case Optimization Tab