Update admin_routes.py

admin_routes.py

@@ -1128,36 +1128,130 @@ async def spark_delete_project(project_name: str, username: str = Depends(verify
 
 # ===================== Test Endpoints =====================
 @router.post("/apis/test")
-async def test_api(api: APICreate, username: str = Depends(verify_token)):
-    """Test API endpoint"""
+async def test_api(api_data: dict = Body(...), username: str = Depends(verify_token)):
+    """Test API endpoint with auth support"""
     import requests
+    import time
     
     try:
-        # Prepare request
+        # Extract test request data if provided
+        test_request = api_data.pop("test_request", None)
+        
+        # Parse the APICreate model
+        api = APICreate(**api_data)
+        
+        # Prepare headers
         headers = api.headers.copy()
         
-        # Add sample auth token for testing
+        # Handle authentication if enabled
+        auth_token = None
         if api.auth and api.auth.get("enabled"):
-            headers["Authorization"] = "Bearer test_token_12345"
+            auth_config = api.auth
+            try:
+                log(f"🔑 Fetching auth token for test...")
+                
+                # Make auth request
+                auth_response = requests.post(
+                    auth_config["token_endpoint"],
+                    json=auth_config.get("token_request_body", {}),
+                    timeout=10
+                )
+                auth_response.raise_for_status()
+                
+                # Extract token from response
+                auth_json = auth_response.json()
+                token_path = auth_config.get("response_token_path", "token").split(".")
+                
+                auth_token = auth_json
+                for path_part in token_path:
+                    auth_token = auth_token.get(path_part)
+                    if auth_token is None:
+                        raise ValueError(f"Token not found at path: {auth_config.get('response_token_path')}")
+                
+                # Add token to headers
+                headers["Authorization"] = f"Bearer {auth_token}"
+                log(f"✅ Auth token obtained: {auth_token[:20]}...")
+                
+            except Exception as e:
+                log(f"❌ Auth failed during test: {e}")
+                return {
+                    "success": False,
+                    "error": f"Authentication failed: {str(e)}"
+                }
         
-        # Make request
-        response = requests.request(
-            method=api.method,
-            url=api.url,
-            headers=headers,
-            json=api.body_template if api.method in ["POST", "PUT", "PATCH"] else None,
-            params=api.body_template if api.method == "GET" else None,
-            timeout=api.timeout_seconds,
-            proxies={"http": api.proxy, "https": api.proxy} if api.proxy else None
-        )
+        # Use test_request if provided, otherwise use body_template
+        request_body = test_request if test_request is not None else api.body_template
         
-        return {
-            "success": True,
+        # Make the actual API request
+        start_time = time.time()
+        
+        # Determine how to send the body based on method
+        if api.method in ["POST", "PUT", "PATCH"]:
+            response = requests.request(
+                method=api.method,
+                url=api.url,
+                headers=headers,
+                json=request_body,
+                timeout=api.timeout_seconds,
+                proxies={"http": api.proxy, "https": api.proxy} if api.proxy else None
+            )
+        elif api.method == "GET":
+            response = requests.request(
+                method=api.method,
+                url=api.url,
+                headers=headers,
+                params=request_body if isinstance(request_body, dict) else None,
+                timeout=api.timeout_seconds,
+                proxies={"http": api.proxy, "https": api.proxy} if api.proxy else None
+            )
+        else:  # DELETE, HEAD, etc.
+            response = requests.request(
+                method=api.method,
+                url=api.url,
+                headers=headers,
+                timeout=api.timeout_seconds,
+                proxies={"http": api.proxy, "https": api.proxy} if api.proxy else None
+            )
+        
+        response_time_ms = int((time.time() - start_time) * 1000)
+        
+        # Prepare response body
+        try:
+            response_body = response.json()
+        except:
+            response_body = response.text
+        
+        # Check if request was successful (2xx status codes)
+        is_success = 200 <= response.status_code < 300
+        
+        result = {
+            "success": is_success,
             "status_code": response.status_code,
-            "response": response.text[:500],  # First 500 chars
-            "headers": dict(response.headers)
+            "response": response_body if isinstance(response_body, str) else json.dumps(response_body, indent=2),
+            "body": json.dumps(response_body, indent=2) if isinstance(response_body, dict) else response_body,
+            "headers": dict(response.headers),
+            "response_time_ms": response_time_ms
+        }
+        
+        # Add error info for non-2xx responses
+        if not is_success:
+            result["error"] = f"HTTP {response.status_code}: {response.reason}"
+        
+        log(f"📋 Test result: {response.status_code} in {response_time_ms}ms")
+        return result
+        
+    except requests.exceptions.Timeout:
+        return {
+            "success": False,
+            "error": f"Request timed out after {api.timeout_seconds} seconds"
+        }
+    except requests.exceptions.ConnectionError as e:
+        return {
+            "success": False,
+            "error": f"Connection error: {str(e)}"
         }
     except Exception as e:
+        log(f"❌ Test API error: {e}")
         return {
             "success": False,
             "error": str(e)