Spaces:
Sleeping
Sleeping
| import logging | |
| import json | |
| from transformers import pipeline, AutoModelForSeq2SeqLM, AutoTokenizer | |
| import gradio as gr | |
| # Configure logging | |
| logging.basicConfig(level=logging.DEBUG, | |
| format='%(asctime)s - %(levelname)s - %(message)s') | |
| logger = logging.getLogger(__name__) | |
| # Try multiple models in succession | |
| MODELS_TO_TRY = [ | |
| "google/flan-t5-large", # More capable than base | |
| "google/flan-t5-xl", # Even more capable | |
| "facebook/bart-large-cnn", # Alternative model | |
| "t5-large" # Fallback T5 model | |
| ] | |
| def load_model(): | |
| for model_name in MODELS_TO_TRY: | |
| try: | |
| logger.info(f"Attempting to load model: {model_name}") | |
| # Load model and tokenizer | |
| model = AutoModelForSeq2SeqLM.from_pretrained(model_name) | |
| tokenizer = AutoTokenizer.from_pretrained(model_name) | |
| # Create pipeline with specific model and tokenizer | |
| generator = pipeline( | |
| "text2text-generation", | |
| model=model, | |
| tokenizer=tokenizer, | |
| max_length=500, | |
| num_return_sequences=1 | |
| ) | |
| logger.info(f"Successfully loaded model: {model_name}") | |
| return generator | |
| except Exception as model_load_error: | |
| logger.error(f"Failed to load model {model_name}: {model_load_error}") | |
| logger.error("Failed to load any model") | |
| return None | |
| # Load model at startup | |
| generator = load_model() | |
| def generate_test_cases(method, url, headers, payload=""): | |
| try: | |
| # Detailed logging | |
| logger.info(f"Generating test cases for:") | |
| logger.info(f"Method: {method}") | |
| logger.info(f"URL: {url}") | |
| logger.info(f"Headers: {headers}") | |
| logger.info(f"Payload: {payload}") | |
| # Validate inputs | |
| if not method or not url: | |
| return "Error: Method and URL are required" | |
| # Safely parse JSON inputs | |
| try: | |
| headers_dict = json.loads(headers) if headers else {} | |
| payload_dict = json.loads(payload) if payload else {} | |
| except json.JSONDecodeError as json_error: | |
| return f"JSON Parsing Error: {json_error}" | |
| # Comprehensive prompt for test case generation | |
| prompt = f""" | |
| Generate detailed API test cases with the following specifications: | |
| Test Case Scenario: API Endpoint Testing | |
| HTTP Method: {method} | |
| API Endpoint: {url} | |
| Request Headers: {json.dumps(headers_dict)} | |
| Request Payload: {json.dumps(payload_dict)} | |
| Test Case Requirements: | |
| 1. Happy Path Scenarios: | |
| - Successful request with valid inputs | |
| - Verify correct response status code | |
| - Validate response structure and content | |
| 2. Negative Test Scenarios: | |
| - Invalid authentication | |
| - Malformed request payload | |
| - Missing required headers | |
| - Out-of-range parameter values | |
| 3. Edge Case Considerations: | |
| - Maximum/minimum input limits | |
| - Special character handling | |
| - Unicode and internationalization testing | |
| 4. Performance and Security Checks: | |
| - Response time validation | |
| - Payload size limits | |
| - Basic security vulnerability checks | |
| Output Format: | |
| For each test case, provide: | |
| - Test Case ID | |
| - Description | |
| - Preconditions | |
| - Input Data | |
| - Expected Result | |
| - Actual Result Verification Steps | |
| """ | |
| # Check if generator is available | |
| if generator is None: | |
| return "Error: No suitable model available for test case generation" | |
| # Generate test cases | |
| try: | |
| response = generator(prompt) | |
| generated_text = response[0]['generated_text'] | |
| logger.info("Test cases generated successfully") | |
| logger.debug(f"Generated Text: {generated_text}") | |
| return generated_text | |
| except Exception as generation_error: | |
| logger.error(f"Test case generation error: {generation_error}") | |
| return f"Error generating test cases: {generation_error}" | |
| except Exception as overall_error: | |
| logger.error(f"Unexpected error: {overall_error}") | |
| return f"Unexpected error: {overall_error}" | |
| # Gradio Interface | |
| iface = gr.Interface( | |
| fn=generate_test_cases, | |
| inputs=[ | |
| gr.Textbox(label="HTTP Method (GET, POST, etc.)", placeholder="e.g., GET, POST"), | |
| gr.Textbox(label="API URL", placeholder="e.g., https://api.example.com/endpoint"), | |
| gr.Textbox(label="Headers (JSON format)", placeholder='e.g., {"Content-Type": "application/json"}'), | |
| gr.Textbox(label="Payload (JSON format)", placeholder='e.g., {"key": "value"}'), | |
| ], | |
| outputs="text", | |
| title="Comprehensive API Test Case Generator", | |
| description="Advanced test case generation using AI-powered language models" | |
| ) | |
| # Main execution | |
| if __name__ == "__main__": | |
| try: | |
| logger.info("Starting Gradio interface") | |
| iface.launch() | |
| except Exception as launch_error: | |
| logger.error(f"Failed to launch Gradio interface: {launch_error}") |