nextog-cli 1.0.0__py3-none-any.whl

nextog/engines/web/elements.py

@@ -0,0 +1,285 @@
+"""
+Element Detector - Detect and explain all system elements for testing
+Identifies every element on a page/system and explains their purpose
+"""
+
+import asyncio
+from typing import Dict, List, Optional, Any
+from pathlib import Path
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+
+# Element type descriptions and testing priorities
+ELEMENT_DESCRIPTIONS = {
+    "button": "Interactive element that triggers actions. Test: click behavior, disabled state, accessibility.",
+    "input_text": "Text input field. Test: validation, max length, special characters, required field.",
+    "input_email": "Email input. Test: format validation, domain check, required field.",
+    "input_password": "Password field. Test: masking, strength validation, visibility toggle.",
+    "input_number": "Number input. Test: min/max range, step values, negative numbers.",
+    "input_checkbox": "Checkbox. Test: checked/unchecked state, group selection, form submission.",
+    "input_radio": "Radio button. Test: single selection, group behavior, default value.",
+    "select": "Dropdown select. Test: options, default value, multi-select, keyboard navigation.",
+    "textarea": "Multi-line text input. Test: resize, max length, line breaks, copy/paste.",
+    "link": "Navigation link. Test: href validity, target behavior, broken links, anchor links.",
+    "image": "Image element. Test: alt text, loading, broken src, responsive sizing, lazy loading.",
+    "video": "Video player. Test: controls, autoplay policy, accessibility, responsive.",
+    "form": "Form container. Test: submission, validation, reset, CSRF protection.",
+    "nav": "Navigation menu. Test: links, responsive menu, keyboard nav, ARIA labels.",
+    "header": "Page header. Test: logo link, navigation, sticky behavior, responsive.",
+    "footer": "Page footer. Test: links, copyright, social links, responsive.",
+    "modal": "Modal/dialog. Test: open/close, overlay click, escape key, focus trap, ARIA.",
+    "table": "Data table. Test: sorting, pagination, responsive, header association.",
+    "list": "List element. Test: ordering, completeness, interactive items.",
+    "iframe": "Embedded content. Test: src validity, sandbox attributes, responsive, security.",
+    "canvas": "Canvas element. Test: rendering, interaction, accessibility fallback.",
+    "svg": "SVG graphic. Test: scaling, accessibility title, interactive elements.",
+    "notification": "Toast/notification. Test: display, dismiss, auto-dismiss timing, accessibility.",
+    "tabs": "Tab component. Test: switching, keyboard nav, ARIA roles, content update.",
+    "accordion": "Accordion component. Test: expand/collapse, multiple open, keyboard nav.",
+    "carousel": "Carousel/slider. Test: navigation, autoplay, pause, touch, accessibility.",
+    "search": "Search component. Test: autocomplete, results, empty state, clear button.",
+    "breadcrumb": "Breadcrumb navigation. Test: hierarchy, links, current page indication.",
+    "pagination": "Pagination. Test: page navigation, limits, current page, disabled states.",
+    "loading": "Loading indicator. Test: display during load, accessibility, timing.",
+    "error": "Error message. Test: display, dismissal, clarity, accessibility.",
+    "tooltip": "Tooltip. Test: hover/focus trigger, content, positioning, accessibility.",
+    "progress": "Progress bar. Test: value accuracy, accessibility, animation.",
+    "sidebar": "Sidebar panel. Test: toggle, responsive, keyboard nav, content.",
+    "cookie_banner": "Cookie consent. Test: accept/reject, persistence, compliance.",
+    "back_to_top": "Scroll to top. Test: visibility, smooth scroll, accessibility.",
+}
+
+# Testing priority mapping
+PRIORITY_MAP = {
+    "button": "critical",
+    "input_text": "critical",
+    "input_email": "critical",
+    "input_password": "critical",
+    "form": "critical",
+    "link": "high",
+    "nav": "high",
+    "modal": "high",
+    "search": "high",
+    "select": "high",
+    "input_checkbox": "high",
+    "input_radio": "high",
+    "table": "high",
+    "tabs": "medium",
+    "accordion": "medium",
+    "carousel": "medium",
+    "image": "medium",
+    "video": "medium",
+    "header": "medium",
+    "footer": "medium",
+    "notification": "medium",
+    "tooltip": "low",
+    "progress": "low",
+    "breadcrumb": "low",
+    "pagination": "low",
+    "loading": "low",
+    "error": "low",
+    "sidebar": "low",
+    "cookie_banner": "low",
+    "back_to_top": "low",
+    "textarea": "medium",
+    "input_number": "medium",
+    "iframe": "high",
+    "canvas": "medium",
+    "svg": "low",
+    "list": "medium",
+}
+
+
+class ElementDetector:
+    """Detect and explain system elements for comprehensive testing"""
+    
+    def __init__(self, settings, db):
+        self.settings = settings
+        self.db = db
+    
+    def detect(self, target: str, explain: bool = True) -> List[Dict]:
+        """Detect all elements on a target page/system"""
+        return asyncio.run(self._detect_async(target, explain))
+    
+    async def _detect_async(self, target: str, explain: bool) -> List[Dict]:
+        """Async element detection"""
+        elements = []
+        
+        try:
+            from playwright.async_api import async_playwright
+            
+            async with async_playwright() as p:
+                browser = await p.chromium.launch(headless=True)
+                page = await browser.new_page()
+                await page.goto(target, wait_until="networkidle")
+                
+                # Detect all element types
+                for elem_type, selector in self._get_selectors().items():
+                    found = await page.query_selector_all(selector)
+                    
+                    for i, elem in enumerate(found):
+                        element_info = {
+                            "name": f"{elem_type}_{i+1}" if len(found) > 1 else elem_type,
+                            "type": elem_type,
+                            "selector": await self._get_unique_selector(elem, elem_type, i),
+                            "description": ELEMENT_DESCRIPTIONS.get(elem_type, f"Element of type {elem_type}") if explain else "",
+                            "priority": PRIORITY_MAP.get(elem_type, "medium"),
+                            "visible": await elem.is_visible(),
+                            "attributes": await self._get_attributes(elem),
+                        }
+                        elements.append(element_info)
+                
+                await browser.close()
+        
+        except ImportError:
+            console.print("[yellow]⚠ Playwright not installed. Using basic detection.[/yellow]")
+            elements = self._basic_detection(target)
+        
+        except Exception as e:
+            console.print(f"[red]Error detecting elements: {e}[/red]")
+        
+        # Sort by priority
+        priority_order = {"critical": 0, "high": 1, "medium": 2, "low": 3}
+        elements.sort(key=lambda x: priority_order.get(x["priority"], 99))
+        
+        # Save to local DB
+        self.db.save_elements(target, elements)
+        
+        return elements
+    
+    def _get_selectors(self) -> Dict[str, str]:
+        """CSS selectors for each element type"""
+        return {
+            "button": "button, [role='button'], input[type='button'], input[type='submit']",
+            "input_text": "input[type='text']:not([role='search'])",
+            "input_email": "input[type='email']",
+            "input_password": "input[type='password']",
+            "input_number": "input[type='number']",
+            "input_checkbox": "input[type='checkbox']",
+            "input_radio": "input[type='radio']",
+            "select": "select",
+            "textarea": "textarea",
+            "link": "a[href]",
+            "image": "img",
+            "video": "video",
+            "form": "form",
+            "nav": "nav",
+            "header": "header",
+            "footer": "footer",
+            "table": "table",
+            "list": "ul, ol",
+            "iframe": "iframe",
+            "svg": "svg",
+            "tabs": "[role='tablist'], .tabs, .tab-container",
+            "accordion": "[role='tablist'][aria-multiselectable], .accordion",
+            "modal": "[role='dialog'], .modal, [aria-modal='true']",
+            "search": "[role='search'], input[type='search'], .search",
+            "notification": "[role='alert'], .notification, .toast",
+            "tooltip": "[role='tooltip'], .tooltip, [data-tooltip]",
+            "breadcrumb": "nav[aria-label='breadcrumb'], .breadcrumb",
+            "pagination": "[role='navigation'][aria-label*='page'], .pagination",
+            "progress": "[role='progressbar'], progress, .progress",
+            "carousel": "[role='tabpanel'], .carousel, .slider",
+            "cookie_banner": ".cookie-banner, [id*='cookie'], [class*='consent']",
+        }
+    
+    async def _get_unique_selector(self, elem, elem_type: str, index: int) -> str:
+        """Generate a unique CSS selector for an element"""
+        try:
+            # Try ID first
+            elem_id = await elem.get_attribute("id")
+            if elem_id:
+                return f"#{elem_id}"
+            
+            # Try class
+            classes = await elem.get_attribute("class")
+            if classes:
+                first_class = classes.split()[0]
+                return f".{first_class}"
+            
+            # Try name attribute
+            name = await elem.get_attribute("name")
+            if name:
+                return f"{elem_type}[name='{name}']"
+            
+            # Fallback
+            return f"{elem_type}:nth-of-type({index + 1})"
+        except Exception:
+            return f"{elem_type}[data-index='{index}']"
+    
+    async def _get_attributes(self, elem) -> Dict[str, str]:
+        """Get relevant attributes of an element"""
+        attrs = {}
+        for attr in ["id", "class", "name", "type", "placeholder", "aria-label", "role", "href", "src", "alt"]:
+            try:
+                value = await elem.get_attribute(attr)
+                if value:
+                    attrs[attr] = value
+            except Exception:
+                pass
+        return attrs
+    
+    def _basic_detection(self, target: str) -> List[Dict]:
+        """Basic element detection without Playwright"""
+        import httpx
+        
+        elements = []
+        try:
+            response = httpx.get(target, follow_redirects=True, timeout=10)
+            html = response.text
+            
+            # Parse basic elements from HTML
+            import re
+            
+            # Find buttons
+            buttons = re.findall(r'<button[^>]*>', html)
+            for i, btn in enumerate(buttons):
+                elements.append({
+                    "name": f"button_{i+1}",
+                    "type": "button",
+                    "selector": f"button:nth-of-type({i+1})",
+                    "description": ELEMENT_DESCRIPTIONS.get("button", ""),
+                    "priority": "critical",
+                    "visible": True,
+                    "attributes": {},
+                })
+            
+            # Find inputs
+            inputs = re.findall(r'<input[^>]*type=["\']([^"\']*)["\'][^>]*>', html)
+            for i, input_type in enumerate(inputs):
+                elem_type = f"input_{input_type}" if input_type in ["text", "email", "password", "number", "checkbox", "radio"] else "input_text"
+                elements.append({
+                    "name": f"input_{input_type}_{i+1}",
+                    "type": elem_type,
+                    "selector": f"input[type='{input_type}']:nth-of-type({i+1})",
+                    "description": ELEMENT_DESCRIPTIONS.get(elem_type, f"Input of type {input_type}"),
+                    "priority": PRIORITY_MAP.get(elem_type, "medium"),
+                    "visible": True,
+                    "attributes": {"type": input_type},
+                })
+            
+            # Find links
+            links = re.findall(r'<a[^>]*href=["\']([^"\']*)["\'][^>]*>', html)
+            for i, href in enumerate(links[:20]):
+                elements.append({
+                    "name": f"link_{i+1}",
+                    "type": "link",
+                    "selector": f"a:nth-of-type({i+1})",
+                    "description": ELEMENT_DESCRIPTIONS.get("link", ""),
+                    "priority": "high",
+                    "visible": True,
+                    "attributes": {"href": href},
+                })
+        
+        except Exception as e:
+            console.print(f"[red]Basic detection error: {e}[/red]")
+        
+        return elements
+    
+    def save_elements(self, elements: List[Dict], output_path: str):
+        """Save detected elements to file"""
+        import json
+        Path(output_path).write_text(json.dumps(elements, indent=2))

nextog/engines/web/responsive.py

@@ -0,0 +1,79 @@
+"""
+Responsive Testing Module
+Tests across multiple viewports and device types
+"""
+
+from typing import Dict, List
+from dataclasses import dataclass
+
+
+@dataclass
+class Viewport:
+    name: str
+    width: int
+    height: int
+    device_scale: float = 1.0
+    is_mobile: bool = False
+
+
+# Standard viewports for testing
+VIEWPORTS = [
+    Viewport("iPhone SE", 375, 667, 2.0, True),
+    Viewport("iPhone 12", 390, 844, 3.0, True),
+    Viewport("iPhone 14 Pro Max", 430, 932, 3.0, True),
+    Viewport("iPad Mini", 768, 1024, 2.0, False),
+    Viewport("iPad Pro", 1024, 1366, 2.0, False),
+    Viewport("Desktop HD", 1366, 768, 1.0, False),
+    Viewport("Desktop FHD", 1920, 1080, 1.0, False),
+    Viewport("Desktop 4K", 3840, 2160, 1.5, False),
+]
+
+
+class ResponsiveTestEngine:
+    """Test responsive design across viewports"""
+    
+    def __init__(self):
+        self.breakpoints = {
+            "mobile": (0, 480),
+            "tablet": (481, 1024),
+            "desktop": (1025, 1920),
+            "wide": (1921, 9999),
+        }
+    
+    def get_test_plan(self, url: str) -> List[Dict]:
+        """Generate responsive test plan"""
+        tests = []
+        
+        for viewport in VIEWPORTS:
+            tests.append({
+                "name": f"{viewport.name} - Layout",
+                "viewport": viewport,
+                "type": "layout",
+                "checks": [
+                    "no_horizontal_scroll",
+                    "content_visible",
+                    "no_overflow",
+                    "images_responsive",
+                    "text_readable",
+                ],
+            })
+            
+            tests.append({
+                "name": f"{viewport.name} - Touch Targets",
+                "viewport": viewport,
+                "type": "touch",
+                "checks": [
+                    "buttons_min_44px" if viewport.is_mobile else "buttons_min_32px",
+                    "links_tappable",
+                    "form_inputs_usable",
+                ],
+            })
+        
+        return tests
+    
+    def analyze_breakpoint(self, viewport: Viewport) -> str:
+        """Determine which breakpoint a viewport falls into"""
+        for bp_name, (min_w, max_w) in self.breakpoints.items():
+            if min_w <= viewport.width <= max_w:
+                return bp_name
+        return "unknown"

nextog/live/__init__.py

@@ -0,0 +1 @@
+"""Live panel and dashboard modules"""

nextog/live/dashboard.py

@@ -0,0 +1,30 @@
+"""Dashboard utilities"""
+
+from typing import Dict
+
+
+class DashboardHelper:
+    """Helper functions for dashboard"""
+    
+    @staticmethod
+    def format_coverage(coverage: float) -> Dict:
+        """Format coverage for display"""
+        color = "red" if coverage < 40 else "yellow" if coverage < 70 else "green"
+        status = "Low" if coverage < 40 else "Medium" if coverage < 70 else "Good" if coverage < 85 else "Excellent"
+        
+        return {
+            "value": round(coverage, 1),
+            "color": color,
+            "status": status,
+            "bar_width": min(coverage, 90),  # Max 90%
+        }
+    
+    @staticmethod
+    def format_duration(seconds: float) -> str:
+        """Format duration for display"""
+        if seconds < 60:
+            return f"{seconds:.1f}s"
+        elif seconds < 3600:
+            return f"{seconds/60:.1f}m"
+        else:
+            return f"{seconds/3600:.1f}h"