Update app.py

app.py

@@ -8,17 +8,15 @@ import numpy as np
 from typing import Dict, Tuple
 import io
 
-# Load semantic similarity model
+# Load semantic similarity model once
 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):
@@ -26,21 +24,16 @@ def is_empty_response(response):
     return False
 
 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"
+        return expected_json == actual_json, "Exact match" if expected_json == actual_json else "Mismatch"
     except Exception as e:
         return False, f"Invalid JSON: {str(e)}"
 
 def run_single_test(endpoint: str, method: str, bearer_token: str,
                     expected_status: int, expected_body: str,
                     payload: str = None, test_name: str = None) -> Dict:
-    """Run a single API test with AI-powered semantic validation"""
     result = {
         'TestName': test_name,
         'Endpoint': endpoint,
@@ -60,16 +53,19 @@ def run_single_test(endpoint: str, method: str, bearer_token: str,
             headers['Authorization'] = f'Bearer {bearer_token.strip()}'
 
         data = None
+        json_payload = None
         if payload and isinstance(payload, str) and payload.strip():
-            data = payload
+            try:
+                json_payload = json.loads(payload)
+            except Exception:
+                data = payload
 
-        # 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, data=data, timeout=10)
+            response = requests.post(endpoint, headers=headers, data=data, json=json_payload, timeout=10)
         elif method.upper() == 'PUT':
-            response = requests.put(endpoint, headers=headers, data=data, timeout=10)
+            response = requests.put(endpoint, headers=headers, data=data, json=json_payload, timeout=10)
         elif method.upper() == 'DELETE':
             response = requests.delete(endpoint, headers=headers, timeout=10)
         else:
@@ -80,13 +76,11 @@ def run_single_test(endpoint: str, method: str, bearer_token: str,
         actual_body = response.text
         result['Actual Body'] = actual_body[:100] + '...' if len(actual_body) > 100 else actual_body
 
-        # Status code check
         if response.status_code != expected_status:
             result['Outcome'] = 'FAIL'
             result['Notes'] = f'Status mismatch: expected {expected_status}, got {response.status_code}'
             return result
 
-        # Body validation
         if not expected_body or is_empty_response(expected_body):
             result['Outcome'] = 'PASS'
             result['Notes'] = 'Status matches, no body validation'
@@ -98,7 +92,6 @@ def run_single_test(endpoint: str, method: str, bearer_token: str,
             result['Notes'] = 'Response is empty (manual review needed)'
             return result
 
-        # JSON validation
         json_match, _ = validate_json_response(expected_body, actual_body)
         if json_match:
             result['Outcome'] = 'PASS'
@@ -106,20 +99,18 @@ def run_single_test(endpoint: str, method: str, bearer_token: str,
             result['Notes'] = 'Exact JSON match'
             return result
 
-        # Semantic similarity
         try:
             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)'
+                result['Notes'] = f'Medium similarity: {similarity:.1%} (review needed)'
             else:
                 result['Outcome'] = 'UNCERTAIN'
-                result['Notes'] = f'Low semantic similarity: {similarity:.1%} (manual review needed)'
+                result['Notes'] = f'Low similarity: {similarity:.1%} (review needed)'
         except Exception as sim_error:
             result['Outcome'] = 'UNCERTAIN'
             result['Notes'] = f'Cannot compute similarity: {str(sim_error)}'
@@ -136,14 +127,15 @@ def run_single_test(endpoint: str, method: str, bearer_token: str,
         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"""
+def process_excel_file(file, bearer_token: str):
     try:
-        df = pd.read_excel(file)
+        if hasattr(file, "name"):
+            df = pd.read_excel(file.name)
+        else:
+            df = pd.read_excel(file)
 
         required_columns = ['Endpoint', 'Method', 'ExpectedStatus', 'ExpectedBody']
         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)}"
 
@@ -161,81 +153,56 @@ def process_excel_file(file, bearer_token: str) -> Tuple[pd.DataFrame, str]:
             results.append(result)
 
         results_df = pd.DataFrame(results)
-
         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**
+        ### 📊 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
-    
     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
 
 # Gradio UI
-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.
-    """)
-
-    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"
-            )
-            run_button = gr.Button("🔍 Run Tests", variant="primary", size="lg")
-        
-        with gr.Column(scale=1):
-            summary_output = gr.Markdown(label="Summary")
-    
-    with gr.Row():
+with gr.Blocks(theme=gr.themes.Soft()) as app:
+    gr.Markdown("## 🚀 API Test Runner with AI-Powered Validation")
+
+    token_state = gr.State("")
+
+    with gr.Tab("Run Tests"):
+        with gr.Group():
+            file_input = gr.File(label="📂 Upload Excel (.xlsx)", file_types=['.xlsx'])
+            token_input = gr.Textbox(label="🔑 Bearer Token", type="password")
+            run_button = gr.Button("▶️ Run Tests", variant="primary")
+
+    with gr.Tab("Results"):
+        summary_output = gr.Markdown()
         results_output = gr.Dataframe(
-            label="Test Results",
-            headers=['TestName','Endpoint','Method','Expected Status','Actual Status',
-                     'Outcome','Similarity','Notes'],
+            headers=['TestName','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")
-    
-    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]
-    )
+        download_output = gr.File()
+
+    token_input.change(fn=lambda t: t, inputs=token_input, outputs=token_state)
+    run_button.click(fn=process_excel_file, inputs=[file_input, token_state], outputs=[results_output, summary_output])
+    download_button.click(fn=download_results, inputs=[results_output], outputs=[download_output])
 
 if __name__ == "__main__":
     app.launch()