Update app.py

app.py

@@ -1,36 +1,265 @@
 import gradio as gr
-import json
+import pandas as pd
 import requests
-from jsonschema import validate, ValidationError
+import json
+from sentence_transformers import SentenceTransformer
+from sklearn.metrics.pairwise import cosine_similarity
+import numpy as np
+from typing import Dict, List, Tuple
+import io
+
+# Load semantic similarity model
+model = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')
+
+def calculate_semantic_similarity(text1: str, text2: str) -> float:
+    """Calculate semantic similarity between two texts using AI embeddings"""
+    embeddings = model.encode([text1, text2])
+    similarity = cosine_similarity([embeddings[0]], [embeddings[1]])[0][0]
+    return float(similarity)
+
+def is_empty_response(response):
+    """Check if response is empty or null"""
+    if response is None or response == '':
+        return True
+    if isinstance(response, str):
+        return response.strip() in ['', 'null', 'undefined']
+    return False
 
-def run_tests(file):
-    results = []
-    with open(file.name, "r") as f:
-        test_cases = json.load(f)
+def validate_json_response(expected, actual) -> Tuple[bool, str]:
+    """Validate if JSON responses match"""
+    try:
+        expected_json = json.loads(expected) if isinstance(expected, str) else expected
+        actual_json = json.loads(actual) if isinstance(actual, str) else actual
+        
+        if expected_json == actual_json:
+            return True, "Exact match"
+        return False, "JSON structure mismatch"
+    except:
+        return False, "Invalid JSON"
 
-    for case in test_cases:
+def run_single_test(endpoint: str, method: str, bearer_token: str, 
+                    expected_status: int, expected_body: str) -> Dict:
+    """Run a single API test with AI-powered semantic validation"""
+    result = {
+        'Endpoint': endpoint,
+        'Method': method,
+        'Expected Status': expected_status,
+        'Actual Status': None,
+        'Expected Body': expected_body[:100] + '...' if len(expected_body) > 100 else expected_body,
+        'Actual Body': None,
+        'Outcome': 'FAIL',
+        'Similarity': None,
+        'Notes': ''
+    }
+    
+    try:
+        # Prepare request
+        headers = {}
+        if bearer_token and bearer_token.strip():
+            headers['Authorization'] = f'Bearer {bearer_token.strip()}'
+        
+        # Make API call
+        if method.upper() == 'GET':
+            response = requests.get(endpoint, headers=headers, timeout=10)
+        elif method.upper() == 'POST':
+            response = requests.post(endpoint, headers=headers, timeout=10)
+        elif method.upper() == 'PUT':
+            response = requests.put(endpoint, headers=headers, timeout=10)
+        elif method.upper() == 'DELETE':
+            response = requests.delete(endpoint, headers=headers, timeout=10)
+        else:
+            result['Notes'] = f'Unsupported method: {method}'
+            return result
+        
+        result['Actual Status'] = response.status_code
+        actual_body = response.text
+        result['Actual Body'] = actual_body[:100] + '...' if len(actual_body) > 100 else actual_body
+        
+        # Check status code
+        status_match = (response.status_code == expected_status)
+        
+        if not status_match:
+            result['Outcome'] = 'FAIL'
+            result['Notes'] = f'Status mismatch: expected {expected_status}, got {response.status_code}'
+            return result
+        
+        # Status matches - now check body
+        if not expected_body or is_empty_response(expected_body):
+            result['Outcome'] = 'PASS'
+            result['Notes'] = 'Status matches, no body validation'
+            return result
+        
+        if is_empty_response(actual_body):
+            result['Outcome'] = 'UNCERTAIN'
+            result['Similarity'] = 0.0
+            result['Notes'] = 'Response is empty (manual review needed)'
+            return result
+        
+        # Try JSON validation first
+        json_match, json_reason = validate_json_response(expected_body, actual_body)
+        if json_match:
+            result['Outcome'] = 'PASS'
+            result['Similarity'] = 1.0
+            result['Notes'] = 'Exact JSON match'
+            return result
+        
+        # Use AI semantic similarity
         try:
-            response = requests.request(
-                method=case["method"],
-                url=f"http://your-api-domain.com{case['endpoint']}",  # Replace with your deployed .NET API URL
-                json=case["payload"]
+            similarity = calculate_semantic_similarity(expected_body, actual_body)
+            result['Similarity'] = round(similarity, 3)
+            
+            if similarity >= 0.75:
+                result['Outcome'] = 'PASS'
+                result['Notes'] = f'High semantic similarity: {similarity:.1%}'
+            elif similarity >= 0.5:
+                result['Outcome'] = 'UNCERTAIN'
+                result['Notes'] = f'Medium semantic similarity: {similarity:.1%} (manual review needed)'
+            else:
+                result['Outcome'] = 'UNCERTAIN'
+                result['Notes'] = f'Low semantic similarity: {similarity:.1%} (manual review needed)'
+        except Exception as sim_error:
+            result['Outcome'] = 'UNCERTAIN'
+            result['Notes'] = f'Cannot compute similarity: {str(sim_error)}'
+        
+        return result
+        
+    except requests.exceptions.Timeout:
+        result['Notes'] = 'Request timeout'
+        return result
+    except requests.exceptions.ConnectionError:
+        result['Notes'] = 'Connection error'
+        return result
+    except Exception as e:
+        result['Notes'] = f'Error: {str(e)}'
+        return result
+
+def process_excel_file(file, bearer_token: str) -> Tuple[pd.DataFrame, str]:
+    """Process uploaded Excel file and run all tests"""
+    try:
+        # Read Excel file
+        df = pd.read_excel(file.name)
+        
+        # Validate columns
+        required_columns = ['Endpoint', 'Method', 'Expected Status Code', 'Expected Response Body']
+        missing_columns = [col for col in required_columns if col not in df.columns]
+        
+        if missing_columns:
+            return None, f"❌ Missing columns: {', '.join(missing_columns)}"
+        
+        # Run tests
+        results = []
+        for idx, row in df.iterrows():
+            result = run_single_test(
+                endpoint=str(row['Endpoint']),
+                method=str(row['Method']),
+                bearer_token=bearer_token,
+                expected_status=int(row['Expected Status Code']),
+                expected_body=str(row['Expected Response Body'])
+            )
+            results.append(result)
+        
+        # Create results DataFrame
+        results_df = pd.DataFrame(results)
+        
+        # Calculate summary
+        total = len(results_df)
+        passed = len(results_df[results_df['Outcome'] == 'PASS'])
+        failed = len(results_df[results_df['Outcome'] == 'FAIL'])
+        uncertain = len(results_df[results_df['Outcome'] == 'UNCERTAIN'])
+        
+        summary = f"""
+        📊 **Test Summary**
+        - Total Tests: {total}
+        - ✅ Passed: {passed}
+        - ❌ Failed: {failed}
+        - ⚠️ Uncertain: {uncertain}
+        """
+        
+        return results_df, summary
+        
+    except Exception as e:
+        return None, f"❌ Error processing file: {str(e)}"
+
+def download_results(df):
+    """Convert DataFrame to Excel for download"""
+    if df is None or df.empty:
+        return None
+    
+    # Create Excel file in memory
+    output = io.BytesIO()
+    with pd.ExcelWriter(output, engine='openpyxl') as writer:
+        df.to_excel(writer, index=False, sheet_name='Test Results')
+    
+    output.seek(0)
+    return output
+
+# Create Gradio interface
+with gr.Blocks(title="API Test Runner with AI", theme=gr.themes.Soft()) as app:
+    gr.Markdown("""
+    # 🚀 API Test Runner with AI-Powered Validation
+    
+    Upload an Excel file with your API test cases and get automated validation with semantic similarity analysis.
+    
+    **Excel Format Required:**
+    - `Endpoint`: API URL
+    - `Method`: GET, POST, PUT, DELETE
+    - `Expected Status Code`: HTTP status code (e.g., 200, 404)
+    - `Expected Response Body`: Expected response text/JSON
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=2):
+            file_input = gr.File(label="Upload Excel File (.xlsx)", file_types=['.xlsx'])
+            token_input = gr.Textbox(
+                label="Bearer Token (Optional)",
+                placeholder="Enter your API bearer token if required",
+                type="password"
             )
-            validate(instance=response.json(), schema=case["expected_schema"])
-            results.append(f"{case['endpoint']} ✅ Passed")
-        except ValidationError as e:
-            results.append(f"{case['endpoint']} ❌ Failed: {e.message}")
-        except Exception as e:
-            results.append(f"{case['endpoint']} ❌ Error: {str(e)}")
-
-    return "\n".join(results)
-
-demo = gr.Interface(
-    fn=run_tests,
-    inputs=gr.File(label="Upload Test Case JSON"),
-    outputs="text",
-    title="AI-Powered Test Runner",
-    description="Upload a JSON file with test cases to validate your .NET/React API."
-)
+            run_button = gr.Button("🔍 Run Tests", variant="primary", size="lg")
+        
+        with gr.Column(scale=1):
+            summary_output = gr.Markdown(label="Summary")
+    
+    with gr.Row():
+        results_output = gr.Dataframe(
+            label="Test Results",
+            headers=['Endpoint', 'Method', 'Expected Status', 'Actual Status', 
+                    'Outcome', 'Similarity', 'Notes'],
+            interactive=False
+        )
+    
+    with gr.Row():
+        download_button = gr.Button("💾 Download Results")
+        download_output = gr.File(label="Download Excel Report")
+    
+    # Event handlers
+    run_button.click(
+        fn=process_excel_file,
+        inputs=[file_input, token_input],
+        outputs=[results_output, summary_output]
+    )
+    
+    download_button.click(
+        fn=download_results,
+        inputs=[results_output],
+        outputs=[download_output]
+    )
+    
+    # Examples
+    gr.Markdown("""
+    ### 📝 Example Excel Format:
+    
+    | Endpoint | Method | Expected Status Code | Expected Response Body |
+    |----------|--------|---------------------|------------------------|
+    | https://api.example.com/users | GET | 200 | [{"id":1,"name":"John"}] |
+    | https://api.example.com/posts | POST | 201 | {"success":true} |
+    
+    ### 🎯 Test Outcomes:
+    - **PASS** (Green): Status matches & high similarity (≥75%)
+    - **UNCERTAIN** (Yellow): Status matches but body similarity is medium (50-75%) or low (<50%)
+    - **FAIL** (Red): Status code mismatch
+    """)
 
+# Launch the app
 if __name__ == "__main__":
-    demo.launch()
+    app.launch()