Gen AI

app.py

@@ -0,0 +1,522 @@
+# ai_test_generator/app.py
+import gradio as gr
+import pandas as pd
+import json
+import logging
+import os
+import html # Keep for potential future use, though not strictly needed now
+
+from scraper import extract_elements
+from genai_handler import generate_test_cases, generate_selenium_script
+from utils import save_elements_to_json, save_test_cases_to_excel, save_scripts_to_excel
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# Ensure output directory exists
+OUTPUT_DIR = "outputs"
+if not os.path.exists(OUTPUT_DIR):
+    os.makedirs(OUTPUT_DIR)
+
+# --- Custom CSS (Keep the enhanced CSS from the previous version) ---
+custom_css = """
+/* === Body and General Styles === */
+body {
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    background: linear-gradient(to bottom right, #e0f2f7, #ffffff); /* Light blue gradient */
+    color: #333;
+    margin: 0;
+    padding: 0;
+}
+
+/* Gradio container adjustments */
+.gradio-container {
+    max-width: 1200px; /* Increase max width */
+    margin: 0 auto !important; /* Center the container */
+    border-radius: 10px;
+    box-shadow: 0 4px 15px rgba(0, 0, 0, 0.1);
+    background-color: #ffffff; /* White background for content area */
+    overflow: hidden; /* Ensure shadows are contained */
+}
+
+/* === Header Simulation === */
+.app-header {
+    background: linear-gradient(to right, #007bff, #0056b3); /* Blue gradient header */
+    color: white;
+    padding: 20px 30px;
+    text-align: center;
+    border-bottom: 3px solid #004085;
+}
+.app-header h1 {
+    margin: 0;
+    font-size: 2.2em;
+    font-weight: 600;
+    letter-spacing: 1px;
+}
+.app-header p {
+    margin-top: 8px;
+    font-size: 1.1em;
+    opacity: 0.9;
+}
+
+/* === Content Area Styling === */
+.control-section {
+    padding: 25px 30px;
+    background-color: #f8f9fa; /* Light grey for control section */
+    border-bottom: 1px solid #dee2e6;
+    border-radius: 8px;
+    margin: 20px;
+    box-shadow: 0 2px 5px rgba(0,0,0, 0.05);
+}
+
+.control-section label {
+    font-weight: 600;
+    color: #0056b3; /* Darker blue for labels */
+    margin-bottom: 8px !important;
+    display: block;
+}
+
+/* Input fields styling */
+.gradio-textbox input[type="text"], .gradio-slider input[type="number"] {
+    border: 1px solid #ced4da;
+    border-radius: 5px;
+    padding: 10px 12px;
+    transition: border-color 0.2s ease, box-shadow 0.2s ease;
+}
+.gradio-textbox input[type="text"]:focus, .gradio-slider input[type="number"]:focus {
+    border-color: #007bff;
+    box-shadow: 0 0 0 2px rgba(0, 123, 255, 0.25);
+    outline: none;
+}
+
+/* Button Styling */
+#generate-button { /* Use ID selector for more specificity */
+    background: linear-gradient(to right, #28a745, #218838); /* Green gradient */
+    color: white !important; /* Ensure text is white */
+    font-weight: bold;
+    border-radius: 25px !important; /* More rounded */
+    padding: 12px 25px !important;
+    border: none !important;
+    box-shadow: 0 2px 5px rgba(0, 0, 0, 0.15);
+    transition: background 0.2s ease, transform 0.1s ease, box-shadow 0.2s ease;
+    cursor: pointer;
+    font-size: 1.1em !important;
+    display: block !important; /* Center button */
+    margin: 15px auto 0 auto !important; /* Center with margin */
+    width: fit-content !important; /* Fit content width */
+}
+#generate-button:hover {
+    background: linear-gradient(to right, #218838, #1e7e34);
+    transform: translateY(-1px);
+    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.2);
+}
+
+/* Status/Logs Accordion */
+.gradio-accordion {
+    border: 1px solid #e0e0e0;
+    border-radius: 8px;
+    margin: 20px;
+    overflow: hidden;
+    box-shadow: 0 1px 3px rgba(0,0,0, 0.05);
+}
+.gradio-accordion > .gr-button { /* Targeting the accordion header button more specifically */
+    background-color: #f1f3f5 !important;
+    border-bottom: 1px solid #e0e0e0 !important;
+    font-weight: 600 !important;
+    color: #495057 !important;
+    padding: 12px 20px !important;
+}
+.gradio-accordion > div { /* Targeting the accordion content */
+     padding: 15px 20px;
+}
+
+/* === Results Section === */
+.results-section {
+    padding: 10px 30px 30px 30px; /* Less top padding, more bottom */
+}
+.results-section h2 {
+    text-align: center;
+    color: #0056b3;
+    margin-bottom: 25px;
+    font-size: 1.8em;
+}
+
+/* Tab Styling */
+.gradio-tabs > .tab-nav button { /* More specific selector for tab buttons */
+    background-color: #f8f9fa;
+    border: 1px solid #dee2e6;
+    border-bottom: none;
+    border-radius: 8px 8px 0 0;
+    padding: 12px 20px;
+    font-weight: 600;
+    color: #495057;
+    transition: background-color 0.2s ease, color 0.2s ease;
+}
+.gradio-tabs > .tab-nav button.selected {
+    background-color: #ffffff;
+    border-color: #dee2e6;
+    color: #007bff;
+    border-bottom: 1px solid #ffffff; /* Hide bottom border of selected tab */
+    position: relative;
+    top: 1px; /* Align with content border */
+}
+.tabitem { /* Style the content area of the tab */
+    border: 1px solid #dee2e6;
+    border-radius: 0 0 8px 8px;
+    padding: 20px;
+    background-color: #ffffff;
+    margin-top: -1px; /* Overlap with tab navigation border */
+}
+
+/* Specific Component Styling within Tabs */
+
+/* JSON Output Code Block */
+.json-output-code .cm-editor { /* Target CodeMirror instance used by gr.Code */
+    max-height: 400px; /* Limit height */
+    border: 1px solid #ced4da;
+    border-radius: 5px;
+}
+/* Force horizontal scroll on the container Gradio puts around the CodeMirror editor */
+.json-output-code > div:first-of-type {
+    overflow-x: auto !important;
+}
+.json-output-code pre { /* Ensure preformatted text scrolls */
+    /* white-space: pre; Remove this as CodeMirror handles it */
+    /* overflow-x: auto !important; Move overflow to container */
+    word-wrap: normal; /* Prevent wrapping */
+    background-color: #f8f9fa; /* Slight background for code */
+    padding: 10px;
+}
+
+
+/* DataFrame Styling */
+.gradio-dataframe table {
+    width: 100%;
+    border-collapse: collapse;
+    box-shadow: 0 1px 3px rgba(0,0,0, 0.1);
+    border-radius: 5px;
+    overflow: hidden; /* Clip shadows */
+}
+.gradio-dataframe th, .gradio-dataframe td {
+    padding: 12px 15px;
+    text-align: left;
+    border-bottom: 1px solid #e0e0e0;
+    vertical-align: top; /* Align content to top */
+}
+.gradio-dataframe th {
+    background-color: #e9ecef; /* Header background */
+    font-weight: 600;
+    color: #495057;
+}
+.gradio-dataframe tr:last-child td {
+    border-bottom: none;
+}
+.gradio-dataframe tr:hover {
+    background-color: #f1f3f5; /* Row hover effect */
+}
+
+/* DataFrame: Test Cases - Steps Column Formatting */
+/* Assumes 'Steps to Execute' is the 4th column (index, ID, Scenario, Steps) */
+.test-cases-df td:nth-child(4) { /* Check index if needed */
+    white-space: pre-wrap; /* Wrap text and respect newlines */
+    word-break: break-word; /* Break long words if needed */
+    min-width: 300px; /* Ensure minimum width */
+    max-width: 500px; /* Add max width */
+}
+
+/* DataFrame: Scripts - Code Column Formatting */
+/* Assumes 'Python Selenium Code' is the 3rd column (index, ID, Code) */
+.scripts-df td:nth-child(3) { /* Check index if needed */
+    white-space: pre;       /* Preserve whitespace (indentation, newlines) */
+    overflow-x: auto;       /* Allow horizontal scrolling for long lines */
+    max-width: 600px;       /* Limit max width before scrolling */
+    font-family: 'Courier New', Courier, monospace; /* Monospace font for code */
+    background-color: #fdfdfe; /* Very light background for code cell */
+    font-size: 0.9em;
+    display: block; /* Treat cell content as a block for scrolling */
+}
+
+/* Download Buttons */
+.gradio-file button {
+    background-color: #6c757d; /* Grey */
+    color: white;
+    border: none;
+    border-radius: 5px;
+    padding: 8px 15px;
+    font-size: 0.9em;
+    transition: background-color 0.2s ease;
+    margin-top: 10px; /* Add some space above download buttons */
+}
+.gradio-file button:hover {
+    background-color: #5a6268;
+}
+
+/* === Footer Simulation === */
+.app-footer {
+    text-align: center;
+    padding: 15px;
+    margin-top: 30px;
+    font-size: 0.9em;
+    color: #6c757d;
+    border-top: 1px solid #dee2e6;
+}
+"""
+
+# Corrected process_website function
+def process_website(url: str, num_test_cases: int):
+    """
+    Main processing function - Corrected for dynamic updates using yield.
+    Orchestrates scraping, test case generation, and script generation.
+    """
+    # --- Initial State ---
+    elements_json_str = "{}" # Start with empty JSON string representation
+    elements_filepath = None
+    test_cases_df = pd.DataFrame(columns=['Test Case ID', 'Test Scenario', 'Steps to Execute', 'Expected Result'])
+    test_cases_filepath = None
+    scripts_df = pd.DataFrame(columns=['Test Case ID', 'Python Selenium Code'])
+    scripts_filepath = None
+    status_updates = []
+
+    def current_outputs():
+        # Helper to package the current state for yielding
+        return (
+            elements_json_str,
+            test_cases_df,
+            scripts_df,
+            elements_filepath,
+            test_cases_filepath,
+            scripts_filepath,
+            "\n".join(status_updates)
+        )
+
+    # --- Input Validation ---
+    if not url or not url.startswith(('http://', 'https://')):
+        status_updates.append("❌ Error: Please enter a valid URL starting with http:// or https://")
+        yield current_outputs()
+        return
+
+    try:
+        status_updates.append("▶️ Processing started...")
+        yield current_outputs()
+
+        # --- Task 1: Web Scraping ---
+        status_updates.append(f"\n🔄 [1/3] Scraping UI elements from {url}...")
+        yield current_outputs() # Update status BEFORE the long call
+
+        elements_data = extract_elements(url)
+
+        if not elements_data:
+            status_updates.append("❌ Error: Failed to extract elements. Check URL or website structure.")
+            yield current_outputs() # Show error
+            return
+
+        elements_json_str = json.dumps(elements_data, indent=4)
+        temp_elements_filename = os.path.join(OUTPUT_DIR, f"elements_{os.path.basename(url).split('.')[0]}.json")
+        elements_filepath = save_elements_to_json(elements_data, filename=os.path.basename(temp_elements_filename))
+        status_updates.append(f"   ✅ Extracted {len(elements_data)} elements. Saved to {elements_filepath}")
+        yield current_outputs() # Update status AND show elements JSON
+
+        # Limit element data size sent to AI
+        max_elements_for_ai = 100
+        if len(elements_data) > max_elements_for_ai:
+             elements_json_str_for_ai = json.dumps(elements_data[:max_elements_for_ai], indent=2)
+             status_updates.append(f"   ℹ️ Note: Using first {max_elements_for_ai} elements for AI analysis due to size.")
+             yield current_outputs() # Show the note immediately
+        else:
+             elements_json_str_for_ai = json.dumps(elements_data, indent=2)
+
+        # --- Task 2: Test Case Generation ---
+        status_updates.append(f"\n🧠 [2/3] Generating {num_test_cases} test cases using GenAI...")
+        yield current_outputs() # Update status BEFORE the long call
+
+        generated_tc_df = generate_test_cases(elements_json_str_for_ai, url, num_test_cases)
+
+        # Check for generation errors reflected in the DataFrame
+        generation_failed = generated_tc_df.empty or \
+                            generated_tc_df['Test Case ID'].isin(['PARSE_ERROR', 'API_ERROR', 'ERROR']).any()
+
+        if generation_failed:
+            status_updates.append("   ⚠️ Warning: Failed to generate valid test cases or encountered an error. See table for details.")
+            if not generated_tc_df.empty:
+                 test_cases_df = generated_tc_df # Display the error DF
+                 temp_tc_filename = os.path.join(OUTPUT_DIR, f"test_cases_{os.path.basename(url).split('.')[0]}_error.xlsx")
+                 test_cases_filepath = save_test_cases_to_excel(test_cases_df, filename=os.path.basename(temp_tc_filename))
+            else:
+                 test_cases_filepath = None # No file if df is completely empty
+            yield current_outputs() # Update status and show error DF
+
+            # Stop if parsing failed completely or DF is empty
+            if test_cases_df.empty or 'PARSE_ERROR' in test_cases_df['Test Case ID'].values:
+                 status_updates.append("   🛑 Stopping process due to critical test case generation failure.")
+                 yield current_outputs()
+                 return
+        else:
+            test_cases_df = generated_tc_df # Update the main DF with successful results
+            temp_tc_filename = os.path.join(OUTPUT_DIR, f"test_cases_{os.path.basename(url).split('.')[0]}.xlsx")
+            test_cases_filepath = save_test_cases_to_excel(test_cases_df, filename=os.path.basename(temp_tc_filename))
+            status_updates.append(f"   ✅ Generated {len(test_cases_df)} test cases. Saved to {test_cases_filepath}")
+            yield current_outputs() # Update status and show test cases DF
+
+
+        # --- Task 3: Selenium Script Generation ---
+        status_updates.append(f"\n🐍 [3/3] Generating Selenium scripts...")
+        yield current_outputs() # Update status BEFORE starting script generation
+
+        scripts_data = []
+        # Filter out potential error rows before iterating
+        valid_test_cases_df = test_cases_df[~test_cases_df['Test Case ID'].isin(['API_ERROR', 'ERROR', 'PARSE_ERROR'])]
+
+        if valid_test_cases_df.empty and not generation_failed:
+             status_updates.append("   ℹ️ No valid test cases found to generate scripts for (check previous warnings).")
+             yield current_outputs()
+        elif not valid_test_cases_df.empty:
+            status_updates.append(f"    Mapping {len(valid_test_cases_df)} test cases to scripts...")
+            yield current_outputs() # Show count before starting loop
+
+            for index, test_case in valid_test_cases_df.iterrows():
+                tc_id = test_case.get('Test Case ID', f'Row_{index}')
+                status_updates.append(f"      ⏳ Generating script for: {tc_id}...")
+                # Yield BEFORE the AI call for this script to show "Generating..." status
+                yield current_outputs()
+
+                script_code = generate_selenium_script(test_case.to_dict(), elements_json_str_for_ai, url)
+                scripts_data.append({
+                    'Test Case ID': tc_id,
+                    'Python Selenium Code': script_code
+                })
+                # Note: We collect all scripts first, then update the DataFrame *once* after the loop
+                # This prevents the DataFrame UI from flickering heavily during the loop.
+                # The status log will show progress for each script.
+
+            # After the loop, create and yield the final scripts DataFrame
+            scripts_df = pd.DataFrame(scripts_data)
+            temp_scripts_filename = os.path.join(OUTPUT_DIR, f"test_scripts_{os.path.basename(url).split('.')[0]}.xlsx")
+            scripts_filepath = save_scripts_to_excel(scripts_data, filename=os.path.basename(temp_scripts_filename))
+            status_updates.append(f"   ✅ Generated {len(scripts_data)} scripts. Saved to {scripts_filepath}")
+            yield current_outputs() # Update status AND show the scripts DF
+
+        else: # Case where TC generation had errors but didn't stop the process
+             status_updates.append("   ℹ️ Skipping script generation due to previous errors in test case generation.")
+             yield current_outputs()
+
+
+        status_updates.append("\n\n🎉 Processing finished successfully!")
+        yield current_outputs() # Final successful state
+
+    except Exception as e:
+        logging.error(f"Critical error in process_website for {url}: {e}", exc_info=True)
+        status_updates.append(f"\n\n❌ CRITICAL ERROR: An unexpected error occurred: {str(e)}")
+        yield current_outputs() # Yield final state with error message
+
+
+# --- Gradio Interface Definition (Keep the layout from the previous version) ---
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"), css=custom_css) as demo:
+
+    # --- Header ---
+    with gr.Row():
+        gr.HTML("""
+            <div class="app-header">
+                <h1>🤖 AI-Driven Test Generation Prototype 🧪</h1>
+                <p>Extract UI Elements → Generate Test Cases → Create Selenium Scripts</p>
+            </div>
+        """)
+
+    # --- Input Controls ---
+    with gr.Group(elem_classes="control-section"):
+        with gr.Row():
+             with gr.Column(scale=3):
+                  url_input = gr.Textbox(
+                      label="Website URL",
+                      placeholder="e.g., https://demoblaze.com",
+                      info="Enter the full public URL of the website to analyze."
+                  )
+             with gr.Column(scale=1):
+                  num_cases_input = gr.Slider(
+                      minimum=1, maximum=10, value=3, step=1, # Default to 3
+                      label="Number of Test Cases",
+                      info="How many test cases should the AI generate?"
+                  )
+        # Use elem_id for more specific CSS targeting if needed
+        start_button = gr.Button("✨ Analyze Website and Generate Tests ✨", variant="primary", elem_id="generate-button")
+
+
+    # --- Status / Logs ---
+    with gr.Accordion("📊 Status & Logs", open=True): # Open by default
+         status_output = gr.Textbox(
+             label="Processing Log",
+             lines=12,
+             interactive=False,
+             show_copy_button=True
+         )
+
+    # --- Results Section ---
+    with gr.Column(elem_classes="results-section"):
+        gr.Markdown("## Results")
+        with gr.Tabs():
+            with gr.TabItem("📄 Extracted UI Elements"):
+                elements_output = gr.Code(
+                    label="elements.json (Preview - scroll horizontally if needed)",
+                    language="json",
+                    interactive=False,
+                    elem_classes="json-output-code" # Apply class for CSS targeting
+                )
+                download_elements = gr.File(label="Download elements.json", scale=0) # Make button smaller
+
+            with gr.TabItem("✅ Generated Test Cases"):
+                test_cases_output = gr.DataFrame(
+                    label="Test Cases (Steps column supports multi-line)",
+                    interactive=False,
+                    wrap=True, # Allow text wrapping generally
+                    elem_classes="test-cases-df" # Apply class for CSS targeting
+                 )
+                download_test_cases = gr.File(label="Download test_cases.xlsx", scale=0)
+
+            with gr.TabItem("🐍 Generated Selenium Scripts"):
+                scripts_output = gr.DataFrame(
+                    label="Selenium Scripts (Code column preserves formatting & scrolls)",
+                    interactive=False,
+                    wrap=False, # Disable wrapping for code column
+                    elem_classes="scripts-df" # Apply class for CSS targeting
+                )
+                download_scripts = gr.File(label="Download test_scripts.xlsx", scale=0)
+
+    # --- Footer ---
+    with gr.Row():
+         gr.HTML("""
+            <div class="app-footer">
+                AI Test Generator Prototype | Using OpenAI Compatible API 
+            </div>
+         """)
+
+
+    # --- Event Handling (Ensure outputs match the yielded tuple order) ---
+    start_button.click(
+        fn=process_website,
+        inputs=[url_input, num_cases_input],
+        outputs=[
+            elements_output,        # 1st element in yielded tuple
+            test_cases_output,      # 2nd
+            scripts_output,         # 3rd
+            download_elements,      # 4th
+            download_test_cases,    # 5th
+            download_scripts,       # 6th
+            status_output           # 7th
+        ]
+    )
+
+    # --- Examples ---
+    gr.Examples(
+        examples=[
+            ["https://demoblaze.com", 5],
+            ["http://the-internet.herokuapp.com/login", 4],
+            ["https://www.wikipedia.org/", 3]
+        ],
+        inputs=[url_input, num_cases_input],
+        label="Example Websites",
+        elem_id="examples-container" # Optional ID for styling
+    )
+
+# --- Launch the Application ---
+if __name__ == "__main__":
+    print("Starting Gradio app with enhanced UI and corrected dynamic updates...")
+    demo.launch(debug=True) # debug=True helps see errors
+

genai_handler.py

@@ -0,0 +1,212 @@
+# ai_test_generator/genai_handler.py
+import os
+import json
+import logging
+import pandas as pd
+from openai import OpenAI, APIError, RateLimitError
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# --- Configuration ---
+# It's better practice to use environment variables for API keys,
+# but using the provided key directly for this specific case.
+API_KEY = "ddc-beta-v7bjela50v-lI9ep55oPFJz7N06MjSh2Asj2AVGaubLqIC"
+BASE_URL = "https://beta.sree.shop/v1"
+MODEL_NAME = "Provider-5/gpt-4o" # Use the specified model
+
+try:
+    client = OpenAI(api_key=API_KEY, base_url=BASE_URL)
+    logging.info(f"OpenAI client initialized for model: {MODEL_NAME}")
+except Exception as e:
+    logging.error(f"Failed to initialize OpenAI client: {e}", exc_info=True)
+    client = None # Ensure client is None if initialization fails
+
+# --- Helper Function to Parse AI Response for Test Cases ---
+def parse_ai_test_cases(response_content: str) -> list[dict]:
+    """Attempts to parse the AI response string into a list of test case dictionaries."""
+    try:
+        # Try parsing directly as JSON if the AI follows instructions perfectly
+        parsed_data = json.loads(response_content)
+        if isinstance(parsed_data, list) and all(isinstance(item, dict) for item in parsed_data):
+             # Basic validation for expected keys (can be made more robust)
+            if parsed_data and all(k in parsed_data[0] for k in ['Test Case ID', 'Test Scenario', 'Steps to Execute', 'Expected Result']):
+                logging.info("Successfully parsed AI response as JSON list of test cases.")
+                return parsed_data
+    except json.JSONDecodeError:
+        logging.warning("AI response is not a direct JSON list. Trying to extract from markdown or other formats.")
+        # Add more sophisticated parsing here if needed (e.g., regex for markdown tables)
+        # For now, return empty if direct JSON parsing fails
+        pass # Fall through to return empty list
+
+    logging.error("Failed to parse AI response into the expected test case format.")
+    return []
+
+
+# --- Test Case Generation ---
+def generate_test_cases(elements_json_str: str, url: str, num_cases: int = 5) -> pd.DataFrame:
+    """
+    Generates test cases using GenAI based on extracted UI elements.
+
+    Args:
+        elements_json_str: A JSON string representing the extracted UI elements.
+        url: The URL of the website being tested (for context).
+        num_cases: The desired number of test cases (default 3-5, AI might vary).
+
+    Returns:
+        A pandas DataFrame containing the generated test cases, or an empty DataFrame on failure.
+    """
+    if not client:
+        logging.error("GenAI client is not available.")
+        return pd.DataFrame()
+
+    prompt = f"""
+    Analyze the following UI elements extracted from the website {url}:
+    ```json
+    {elements_json_str}
+    ```
+
+    Based on these elements, generate {num_cases} meaningful test cases covering common user interactions like navigation, form interaction (if any), viewing content, etc. Focus on positive and potentially simple negative scenarios relevant to the visible elements.
+
+    Present the test cases ONLY as a valid JSON list of objects. Each object must have the following keys:
+    - "Test Case ID": A unique identifier (e.g., TC001, TC002).
+    - "Test Scenario": A brief description of the test objective.
+    - "Steps to Execute": Numbered steps describing how to perform the test manually. Mention specific element identifiers (text, id, placeholder) where possible from the JSON above.
+    - "Expected Result": What should happen after executing the steps.
+
+    Example format for a single test case object:
+    {{
+      "Test Case ID": "TC001",
+      "Test Scenario": "Verify user can navigate to the 'Contact' page",
+      "Steps to Execute": "1. Go to the homepage.\n2. Click on the link with text 'Contact'.",
+      "Expected Result": "The contact page should load successfully, displaying contact information or a contact form."
+    }}
+
+    Ensure the entire output is *only* the JSON list, starting with '[' and ending with ']'. Do not include any introductory text, explanations, or markdown formatting outside the JSON structure itself.
+    """
+
+    logging.info(f"Generating {num_cases} test cases for {url}...")
+    try:
+        response = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are an expert QA engineer generating test cases from UI elements."},
+                {"role": "user", "content": prompt}
+            ],
+            temperature=0.5, # Lower temperature for more predictable structure
+            max_tokens=1500  # Adjust as needed
+        )
+
+        response_content = response.choices[0].message.content.strip()
+        logging.info("Raw AI Response for Test Cases:\n" + response_content) # Log the raw response
+
+        # Parse the response
+        test_cases_list = parse_ai_test_cases(response_content)
+
+        if not test_cases_list:
+             logging.error("Failed to parse test cases from AI response.")
+             # Attempt to return raw response in a placeholder format if parsing fails
+             return pd.DataFrame([{'Test Case ID': 'PARSE_ERROR', 'Test Scenario': 'Failed to parse AI response', 'Steps to Execute': response_content, 'Expected Result': 'N/A'}])
+
+
+        df = pd.DataFrame(test_cases_list)
+        # Ensure standard columns exist, even if AI missed some
+        for col in ['Test Case ID', 'Test Scenario', 'Steps to Execute', 'Expected Result']:
+            if col not in df.columns:
+                df[col] = 'N/A' # Add missing columns with default value
+        df = df[['Test Case ID', 'Test Scenario', 'Steps to Execute', 'Expected Result']] # Enforce order
+
+        logging.info(f"Successfully generated and parsed {len(df)} test cases.")
+        return df
+
+    except RateLimitError as e:
+        logging.error(f"API Rate Limit Error: {e}")
+        return pd.DataFrame([{'Test Case ID': 'API_ERROR', 'Test Scenario': 'Rate Limit Reached', 'Steps to Execute': str(e), 'Expected Result': 'N/A'}])
+    except APIError as e:
+        logging.error(f"API Error during test case generation: {e}")
+        return pd.DataFrame([{'Test Case ID': 'API_ERROR', 'Test Scenario': 'API Communication Issue', 'Steps to Execute': str(e), 'Expected Result': 'N/A'}])
+    except Exception as e:
+        logging.error(f"Unexpected error during test case generation: {e}", exc_info=True)
+        return pd.DataFrame([{'Test Case ID': 'ERROR', 'Test Scenario': 'Unexpected Error', 'Steps to Execute': str(e), 'Expected Result': 'N/A'}])
+
+
+# --- Selenium Script Generation ---
+def generate_selenium_script(test_case: dict, elements_json_str: str, url: str) -> str:
+    """
+    Generates a Python Selenium script for a single test case using GenAI.
+
+    Args:
+        test_case: A dictionary representing a single test case (needs 'Test Case ID', 'Steps to Execute').
+        elements_json_str: A JSON string of extracted UI elements for context.
+        url: The target website URL.
+
+    Returns:
+        A string containing the generated Python Selenium script, or an error message string.
+    """
+    if not client:
+        logging.error("GenAI client is not available.")
+        return "Error: GenAI client not initialized."
+
+    test_case_id = test_case.get('Test Case ID', 'Unknown TC')
+    steps = test_case.get('Steps to Execute', 'No steps provided.')
+    scenario = test_case.get('Test Scenario', 'No scenario provided.')
+
+    prompt = f"""
+    Generate a complete, runnable Python Selenium script to automate the following test case for the website {url}.
+
+    Test Case ID: {test_case_id}
+    Test Scenario: {scenario}
+    Steps to Execute:
+    {steps}
+
+    Use the following UI element details extracted from the page for context when choosing selectors. Prefer using ID, then Name, then CSS Selector, then Link Text, then XPath. Handle potential waits for elements to be clickable or visible.
+    ```json
+    {elements_json_str}
+    ```
+
+    The script should:
+    1. Include necessary imports (Selenium webdriver, By, time, etc.).
+    2. Set up the ChromeDriver (using webdriver-manager is preferred). Run in headless mode.
+    3. Navigate to the base URL: {url}.
+    4. Implement the test steps described above using Selenium commands (find_element, click, send_keys, etc.). Use robust locators based on the provided element details. Include reasonable waits (e.g., `time.sleep(1)` or explicit waits) after actions like clicks or navigation.
+    5. Include a basic assertion relevant to the 'Expected Result' or the final step (e.g., check page title, check for an element's presence/text). If the expected result is vague, make a reasonable assertion based on the steps.
+    6. Print a success or failure message to the console based on the assertion.
+    7. Include teardown code to close the browser (`driver.quit()`) in a `finally` block.
+    8. Be fully contained within a single Python code block.
+
+    Output *only* the Python code for the script. Do not include any explanations, introductory text, or markdown formatting like ```python ... ```.
+    """
+
+    logging.info(f"Generating Selenium script for Test Case ID: {test_case_id}...")
+    try:
+        response = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are an expert QA automation engineer generating Python Selenium scripts."},
+                {"role": "user", "content": prompt}
+            ],
+            temperature=0.3, # Low temperature for more deterministic code generation
+            max_tokens=2000 # Allow ample space for code
+        )
+
+        script_code = response.choices[0].message.content.strip()
+
+        # Basic cleanup: remove potential markdown fences if AI includes them
+        if script_code.startswith("```python"):
+            script_code = script_code[len("```python"):].strip()
+        if script_code.endswith("```"):
+            script_code = script_code[:-len("```")].strip()
+
+        logging.info(f"Successfully generated script for {test_case_id}.")
+        # Log first few lines of the script for verification
+        logging.debug(f"Generated script (first 100 chars): {script_code[:100]}...")
+        return script_code
+
+    except RateLimitError as e:
+        logging.error(f"API Rate Limit Error during script generation for {test_case_id}: {e}")
+        return f"# Error: API Rate Limit Reached\n# {e}"
+    except APIError as e:
+        logging.error(f"API Error during script generation for {test_case_id}: {e}")
+        return f"# Error: API Communication Issue\n# {e}"
+    except Exception as e:
+        logging.error(f"Unexpected error during script generation for {test_case_id}: {e}", exc_info=True)
+        return f"# Error: Unexpected error during script generation\n# {e}"

requirements.txt

@@ -0,0 +1,9 @@
+beautifulsoup4
+selenium
+webdriver-manager
+openai
+pandas
+openpyxl
+gradio
+lxml 
+requests 

scraper.py

@@ -0,0 +1,150 @@
+# ai_test_generator/scraper.py
+import time
+import json
+from selenium import webdriver
+from selenium.webdriver.chrome.service import Service
+from selenium.webdriver.chrome.options import Options
+from webdriver_manager.chrome import ChromeDriverManager
+from bs4 import BeautifulSoup
+import logging
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+def extract_elements(url: str) -> list[dict]:
+    """
+    Scrapes a website URL to extract buttons, links, input fields, and forms.
+
+    Args:
+        url: The public URL of the website to scrape.
+
+    Returns:
+        A list of dictionaries, each representing an extracted UI element.
+        Returns an empty list if scraping fails.
+    """
+    logging.info(f"Starting scraping for URL: {url}")
+    extracted_elements = []
+
+    chrome_options = Options()
+    chrome_options.add_argument("--headless") # Run headless (no GUI)
+    chrome_options.add_argument("--no-sandbox")
+    chrome_options.add_argument("--disable-dev-shm-usage")
+    chrome_options.add_argument("--disable-gpu") # Recommended for headless
+    chrome_options.add_argument("user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36") # Set user agent
+
+    service = Service(ChromeDriverManager().install())
+    driver = None
+
+    try:
+        driver = webdriver.Chrome(service=service, options=chrome_options)
+        driver.set_page_load_timeout(30) # Set timeout for page load
+        driver.get(url)
+        # Allow some time for dynamic content to potentially load
+        # A more robust solution might use WebDriverWait
+        time.sleep(3)
+
+        page_source = driver.page_source
+        soup = BeautifulSoup(page_source, 'lxml') # Use lxml parser
+
+        # --- Extract Buttons ---
+        buttons = soup.find_all('button')
+        for btn in buttons:
+            element_data = {
+                'type': 'button',
+                'text': btn.get_text(strip=True),
+                'id': btn.get('id'),
+                'name': btn.get('name'),
+                'class': btn.get('class'),
+                'attributes': {k: v for k, v in btn.attrs.items() if k not in ['id', 'name', 'class']}
+            }
+            extracted_elements.append(element_data)
+        logging.info(f"Found {len(buttons)} buttons.")
+
+        # --- Extract Links ---
+        links = soup.find_all('a')
+        for link in links:
+            element_data = {
+                'type': 'link',
+                'text': link.get_text(strip=True),
+                'href': link.get('href'),
+                'id': link.get('id'),
+                'class': link.get('class'),
+                'attributes': {k: v for k, v in link.attrs.items() if k not in ['id', 'class', 'href']}
+            }
+            extracted_elements.append(element_data)
+        logging.info(f"Found {len(links)} links.")
+
+        # --- Extract Input Fields ---
+        inputs = soup.find_all('input')
+        for inp in inputs:
+            element_data = {
+                'type': 'input',
+                'input_type': inp.get('type', 'text'), # Default to 'text' if type not specified
+                'id': inp.get('id'),
+                'name': inp.get('name'),
+                'placeholder': inp.get('placeholder'),
+                'value': inp.get('value'),
+                'class': inp.get('class'),
+                'attributes': {k: v for k, v in inp.attrs.items() if k not in ['id', 'name', 'class', 'type', 'placeholder', 'value']}
+            }
+            extracted_elements.append(element_data)
+        logging.info(f"Found {len(inputs)} input fields.")
+
+        # --- Extract Forms ---
+        forms = soup.find_all('form')
+        for form in forms:
+            form_elements = []
+            # Find elements within this specific form
+            for child_input in form.find_all('input'):
+                 form_elements.append({
+                    'tag': 'input',
+                    'type': child_input.get('type'),
+                    'id': child_input.get('id'),
+                    'name': child_input.get('name')
+                 })
+            for child_button in form.find_all('button'):
+                 form_elements.append({
+                    'tag': 'button',
+                    'type': child_button.get('type'),
+                    'id': child_button.get('id'),
+                    'name': child_button.get('name'),
+                    'text': child_button.get_text(strip=True)
+                 })
+            # Add other form element types if needed (select, textarea)
+
+            element_data = {
+                'type': 'form',
+                'id': form.get('id'),
+                'action': form.get('action'),
+                'method': form.get('method'),
+                'class': form.get('class'),
+                'contained_elements': form_elements,
+                'attributes': {k: v for k, v in form.attrs.items() if k not in ['id', 'class', 'action', 'method']}
+            }
+            extracted_elements.append(element_data)
+        logging.info(f"Found {len(forms)} forms.")
+
+        logging.info(f"Successfully extracted {len(extracted_elements)} elements in total.")
+
+    except Exception as e:
+        logging.error(f"Error during scraping URL {url}: {e}", exc_info=True)
+        # Return empty list on error, Gradio app will handle this
+        return []
+    finally:
+        if driver:
+            driver.quit()
+            logging.info("WebDriver closed.")
+
+    return extracted_elements
+
+# Example usage (optional, for testing scraper independently)
+# if __name__ == '__main__':
+#     test_url = "https://demoblaze.com/"
+#     elements = extract_elements(test_url)
+#     if elements:
+#         print(f"Extracted {len(elements)} elements.")
+#         # Save to a temporary file for inspection
+#         with open("temp_elements.json", "w", encoding="utf-8") as f:
+#             json.dump(elements, f, indent=4)
+#         print("Saved results to temp_elements.json")
+#     else:
+#         print("Scraping failed.")

utils.py

@@ -0,0 +1,56 @@
+# ai_test_generator/utils.py
+import json
+import pandas as pd
+import logging
+import os
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+OUTPUT_DIR = "outputs" # Define output directory
+
+def save_elements_to_json(elements: list[dict], filename: str = "elements.json") -> str:
+    """Saves extracted elements to a JSON file."""
+    if not os.path.exists(OUTPUT_DIR):
+        os.makedirs(OUTPUT_DIR)
+    filepath = os.path.join(OUTPUT_DIR, filename)
+    try:
+        with open(filepath, "w", encoding="utf-8") as f:
+            json.dump(elements, f, indent=4)
+        logging.info(f"Successfully saved elements to {filepath}")
+        return filepath
+    except Exception as e:
+        logging.error(f"Error saving elements to JSON file {filepath}: {e}", exc_info=True)
+        return ""
+
+def save_test_cases_to_excel(test_cases_df: pd.DataFrame, filename: str = "test_cases.xlsx") -> str:
+    """Saves test cases DataFrame to an Excel file."""
+    if not os.path.exists(OUTPUT_DIR):
+        os.makedirs(OUTPUT_DIR)
+    filepath = os.path.join(OUTPUT_DIR, filename)
+    try:
+        test_cases_df.to_excel(filepath, index=False, engine='openpyxl')
+        logging.info(f"Successfully saved test cases to {filepath}")
+        return filepath
+    except Exception as e:
+        logging.error(f"Error saving test cases to Excel file {filepath}: {e}", exc_info=True)
+        return ""
+
+def save_scripts_to_excel(scripts_data: list[dict], filename: str = "test_scripts.xlsx") -> str:
+    """Saves generated scripts along with Test Case IDs to an Excel file."""
+    if not os.path.exists(OUTPUT_DIR):
+        os.makedirs(OUTPUT_DIR)
+    filepath = os.path.join(OUTPUT_DIR, filename)
+    try:
+        df = pd.DataFrame(scripts_data)
+        # Ensure consistent column order
+        if not df.empty:
+             df = df[['Test Case ID', 'Python Selenium Code']]
+        else:
+             # Create empty DataFrame with columns if no scripts were generated
+             df = pd.DataFrame(columns=['Test Case ID', 'Python Selenium Code'])
+
+        df.to_excel(filepath, index=False, engine='openpyxl')
+        logging.info(f"Successfully saved scripts to {filepath}")
+        return filepath
+    except Exception as e:
+        logging.error(f"Error saving scripts to Excel file {filepath}: {e}", exc_info=True)
+        return ""