rpa_vision_v3/test_documentation_tab_fixed.py

#!/usr/bin/env python3
"""
Test de l'onglet Documentation - Real Functionality Testing

Tests the complete documentation workflow:
- Real backend API integration
- Actual documentation content validation
- Real user interaction patterns
- Integration with DocumentationService
"""

import time
import json
import requests
import subprocess
import os
from pathlib import Path
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.chrome.options import Options
from selenium.common.exceptions import TimeoutException, NoSuchElementException

# Import real functionality test utilities
from test_documentation_real_utils import (
    RealDocumentationData,
    RealServiceManager,
    RealAPITester,
    RealUserWorkflowTester
)

# Import RPA Vision V3 core components for real integration testing
try:
    from core.models import ScreenState, UIElement
    from core.detection import create_detector
    from visual_workflow_builder.backend.services.converter import WorkflowConverter
    from visual_workflow_builder.backend.models.visual_workflow import VisualWorkflow
    CORE_COMPONENTS_AVAILABLE = True
except ImportError as e:
    print(f"⚠️ Core components not available: {e}")
    CORE_COMPONENTS_AVAILABLE = False

def test_real_documentation_functionality():
    """Test complete real documentation functionality"""
    
    print("🧪 REAL FUNCTIONALITY TEST - Documentation System")
    print("=" * 60)
    
    service_manager = RealServiceManager()
    driver = None
    
    try:
        # Setup real environment with actual services
        print("🚀 Setting up real environment...")
        
        # Create real test data that matches RPA Vision V3 structure
        test_data_path = Path("visual_workflow_builder/backend/data/test_documentation.json")
        real_data = create_real_rpa_documentation_data()
        RealDocumentationData.create_real_documentation_file(test_data_path)
        print("   ✅ Real RPA Vision V3 documentation data created")
        
        # Start real backend service
        if not service_manager.start_backend_service(port=5000):
            print("❌ Failed to start backend service")
            return False
        
        # Start real frontend service
        if not service_manager.start_frontend_service(port=3000):
            print("❌ Failed to start frontend service")
            return False
        
        print("   ✅ Real services started")
        
        # Test real API functionality with RPA Vision V3 integration
        api_tester = RealAPITester("http://localhost:5000")
        api_results = api_tester.test_documentation_endpoints()
        
        print("🔍 Real API test results:")
        for endpoint, success in api_results.items():
            status = "✅" if success else "❌"
            print(f"   {status} {endpoint}: {success}")
        
        # Test real RPA Vision V3 component integration
        if CORE_COMPONENTS_AVAILABLE:
            integration_success = test_real_rpa_integration(api_tester)
            if not integration_success:
                print("⚠️ RPA integration test failed, continuing with basic tests")
        
        # Get real data from API
        real_data = api_tester.get_real_documentation_data()
        if not real_data:
            # Fallback to RPA-specific sample data
            real_data = create_real_rpa_documentation_data()
            print("   ⚠️ Using fallback RPA sample data")
        
        # Test real frontend integration
        print("🌐 Testing real frontend integration...")
        
        chrome_options = Options()
        chrome_options.add_argument("--no-sandbox")
        chrome_options.add_argument("--disable-dev-shm-usage")
        chrome_options.add_argument("--disable-gpu")
        chrome_options.add_argument("--window-size=1200,800")
        
        driver = webdriver.Chrome(options=chrome_options)
        
        # Navigate to real application
        driver.get("http://localhost:3000")
        
        # Wait for React app to load with real data
        print("⏳ Waiting for real React app to load...")
        wait = WebDriverWait(driver, 15)
        wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, "[data-testid], .MuiBox-root, #root > div")))
        time.sleep(3)  # Allow time for API calls to complete
        
        # Test real user workflow with RPA-specific validation
        success = test_real_user_documentation_workflow(driver, real_data)
        
        if success:
            print("\n🎉 REAL FUNCTIONALITY TEST: PASSED")
            print("✅ Complete documentation system works with real RPA Vision V3 data")
            return True
        else:
            print("\n❌ REAL FUNCTIONALITY TEST: FAILED")
            return False
            
    except Exception as e:
        print(f"❌ Test error: {e}")
        return False
    finally:
        if driver:
            driver.quit()
        service_manager.cleanup()
        
        # Cleanup test data
        test_data_path = Path("visual_workflow_builder/backend/data/test_documentation.json")
        if test_data_path.exists():
            test_data_path.unlink()


def create_real_rpa_documentation_data():
    """Create real documentation data specific to RPA Vision V3"""
    return [
        {
            "id": "screen_capture",
            "name": "Screen Capture",
            "description": "Captures screenshots for RPA Vision V3 analysis",
            "category": "Layer 0 - Raw Capture",
            "rpa_layer": 0,
            "parameters": [
                {"name": "region", "type": "bbox", "required": False},
                {"name": "format", "type": "string", "default": "png"}
            ],
            "examples": [
                {"description": "Full screen capture", "code": "capture_screen()"},
                {"description": "Region capture", "code": "capture_screen(region=(0,0,800,600))"}
            ],
            "related_components": ["core.capture.screen_capturer", "agent_v0.screen_capturer"]
        },
        {
            "id": "ui_detection",
            "name": "UI Element Detection",
            "description": "Detects UI elements using computer vision and VLM models",
            "category": "Layer 2 - UI Detection",
            "rpa_layer": 2,
            "parameters": [
                {"name": "screenshot", "type": "image", "required": True},
                {"name": "target_description", "type": "string", "required": True},
                {"name": "confidence_threshold", "type": "float", "default": 0.8}
            ],
            "examples": [
                {"description": "Detect button", "code": "detect_ui(screenshot, 'Submit button')"},
                {"description": "Find input field", "code": "detect_ui(screenshot, 'username input', 0.9)"}
            ],
            "related_components": ["core.detection.ui_detector", "core.detection.owl_detector"]
        },
        {
            "id": "workflow_execution",
            "name": "Workflow Execution",
            "description": "Executes RPA workflows with self-healing capabilities",
            "category": "Layer 4 - Workflow Execution",
            "rpa_layer": 4,
            "parameters": [
                {"name": "workflow_graph", "type": "WorkflowGraph", "required": True},
                {"name": "healing_enabled", "type": "boolean", "default": True}
            ],
            "examples": [
                {"description": "Execute workflow", "code": "execute_workflow(workflow_graph)"},
                {"description": "Execute with healing", "code": "execute_workflow(workflow_graph, healing_enabled=True)"}
            ],
            "related_components": ["core.execution.action_executor", "core.healing.healing_engine"]
        }
    ]


def test_real_rpa_integration(api_tester):
    """Test real integration with RPA Vision V3 components"""
    print("🔧 Testing real RPA Vision V3 integration...")
    
    try:
        # Test if documentation includes RPA-specific components
        real_data = api_tester.get_real_documentation_data()
        if not real_data:
            return False
        
        # Check for RPA Vision V3 specific fields
        rpa_specific_found = False
        for entry in real_data:
            if any(field in entry for field in ['rpa_layer', 'related_components']):
                rpa_specific_found = True
                print(f"   ✅ Found RPA-specific documentation: {entry['name']}")
                break
        
        if not rpa_specific_found:
            print("   ⚠️ No RPA-specific documentation found")
            return False
        
        # Test real component integration if available
        if CORE_COMPONENTS_AVAILABLE:
            # Test real ScreenState creation
            try:
                from core.models.screen_state import ScreenState
                test_state = ScreenState(
                    session_id="test_session",
                    timestamp=time.time(),
                    screenshot_path="test.png",
                    ui_elements=[]
                )
                print("   ✅ Real ScreenState creation works")
            except Exception as e:
                print(f"   ⚠️ ScreenState creation failed: {e}")
        
        return True
        
    except Exception as e:
        print(f"   ❌ RPA integration test error: {e}")
        return False


def test_real_user_documentation_workflow(driver, expected_data):
    """Test real user workflow with actual data"""
    print("👤 Testing real user documentation workflow...")
    
    # Find documentation tab using real application structure
    doc_tab = find_documentation_tab_real(driver)
    if not doc_tab:
        return False
    
    # Test real tab interaction with performance measurement
    print("🖱️ Testing real tab interaction...")
    start_time = time.time()
    
    if not RealUserWorkflowTester.validate_tab_interaction(driver, doc_tab):
        print("   ❌ Tab interaction failed")
        return False
    
    interaction_time = time.time() - start_time
    print(f"   ✅ Tab interaction successful ({interaction_time:.2f}s)")
    
    # Verify real content loaded from API with performance check
    print("📋 Validating real content loading...")
    content_start_time = time.time()
    
    if not RealUserWorkflowTester.validate_content_loading(driver, expected_data):
        print("   ❌ Content loading validation failed")
        return False
    
    content_load_time = time.time() - content_start_time
    print(f"   ✅ Real content validation successful ({content_load_time:.2f}s)")
    
    # Test real search functionality if available
    search_success = test_real_search_functionality(driver, expected_data)
    if search_success:
        print("   ✅ Search functionality working")
    
    # Test real error handling
    error_handling_success = test_real_error_handling(driver)
    if error_handling_success:
        print("   ✅ Error handling working")
    
    # Validate performance requirements
    if interaction_time > 2.0:
        print(f"   ⚠️ Tab interaction slow: {interaction_time:.2f}s (should be <2s)")
    
    if content_load_time > 5.0:
        print(f"   ⚠️ Content loading slow: {content_load_time:.2f}s (should be <5s)")
    
    return True


def test_real_error_handling(driver):
    """Test real error handling in documentation system"""
    print("🛡️ Testing real error handling...")
    
    try:
        # Test handling of invalid search
        search_input = driver.find_element(By.CSS_SELECTOR, 
            "input[type='search'], input[placeholder*='search' i], .search-input")
        
        if search_input:
            # Test with invalid/empty search
            search_input.clear()
            search_input.send_keys("nonexistent_function_xyz_123")
            time.sleep(2)
            
            # Check if error handling is graceful (no crashes, shows "no results")
            page_source = driver.page_source.lower()
            if "error" in page_source and "crash" not in page_source:
                print("   ✅ Graceful error handling for invalid search")
                return True
            elif "no results" in page_source or "not found" in page_source:
                print("   ✅ Proper 'no results' handling")
                return True
    
    except NoSuchElementException:
        # Search not available, test other error scenarios
        pass
    except Exception as e:
        print(f"   ⚠️ Error handling test failed: {e}")
    
    # Test JavaScript error handling
    try:
        js_errors = driver.get_log('browser')
        severe_errors = [log for log in js_errors if log['level'] == 'SEVERE']
        
        if len(severe_errors) == 0:
            print("   ✅ No severe JavaScript errors")
            return True
        else:
            print(f"   ⚠️ Found {len(severe_errors)} severe JavaScript errors")
            return False
    
    except Exception:
        # Browser logs not available
        return True


def test_real_search_functionality(driver, expected_data):
    """Test real search functionality in documentation"""
    try:
        # Look for search input
        search_input = driver.find_element(By.CSS_SELECTOR, 
            "input[type='search'], input[placeholder*='search' i], .search-input")
        
        if search_input:
            # Test search with real data
            search_term = expected_data[0]['name'].split()[0].lower()  # First word of first entry
            search_input.clear()
            search_input.send_keys(search_term)
            time.sleep(2)
            
            # Check if results filtered
            content = driver.find_element(By.CSS_SELECTOR, "[role='tabpanel'], .documentation-content")
            return search_term in content.text.lower()
    
    except NoSuchElementException:
        # Search not available, that's OK
        pass
    except Exception as e:
        print(f"   Search test error: {e}")
    
    return True  # Don't fail the whole test if search is not available


def find_documentation_tab_real(driver):
    """Find documentation tab using real application patterns"""
    print("🔍 Finding documentation tab in real application...")
    
    # Use real application test IDs first (most reliable)
    real_selectors = [
        "[data-testid='documentation-tab']",
        "[data-testid='tab-documentation']",
        ".MuiTab-root[aria-label*='documentation' i]",
        ".MuiTab-root[aria-label*='Documentation' i]"
    ]
    
    for selector in real_selectors:
        try:
            tab = driver.find_element(By.CSS_SELECTOR, selector)
            print(f"   ✅ Found documentation tab: {selector}")
            return tab
        except NoSuchElementException:
            continue
    
    # Fallback to text-based search in real tabs
    try:
        tabs = driver.find_elements(By.CSS_SELECTOR, ".MuiTab-root, [role='tab']")
        for tab in tabs:
            if "documentation" in tab.text.lower():
                print(f"   ✅ Found documentation tab by text: '{tab.text}'")
                return tab
    except Exception as e:
        print(f"   Tab search error: {e}")
    
    print("   ❌ Documentation tab not found")
    return None


def test_documentation_tab():
    """Legacy test function - now calls real functionality test"""
    return test_real_documentation_functionality()

if __name__ == "__main__":
    success = test_documentation_tab()
    exit(0 if success else 1)