nextog-cli 1.0.0__py3-none-any.whl

nextog/engines/web/accessibility.py

@@ -0,0 +1,191 @@
+"""
+Accessibility Testing Module - WCAG 2.1 compliance testing
+"""
+
+from typing import Dict, List, Any
+
+
+# WCAG 2.1 Guidelines
+WCAG_GUIDELINES = {
+    "1.1.1": {"name": "Non-text Content", "level": "A", "description": "All non-text content has text alternative"},
+    "1.3.1": {"name": "Info and Relationships", "level": "A", "description": "Information and relationships can be programmatically determined"},
+    "1.3.4": {"name": "Orientation", "level": "AA", "description": "Content does not restrict its view to a single display orientation"},
+    "1.3.5": {"name": "Identify Input Purpose", "level": "AA", "description": "Input field purpose can be programmatically determined"},
+    "1.4.1": {"name": "Use of Color", "level": "A", "description": "Color is not used as the only visual means of conveying information"},
+    "1.4.3": {"name": "Contrast (Minimum)", "level": "AA", "description": "Text has contrast ratio of at least 4.5:1"},
+    "1.4.4": {"name": "Resize Text", "level": "AA", "description": "Text can be resized up to 200% without loss of content"},
+    "1.4.10": {"name": "Reflow", "level": "AA", "description": "Content reflows at 320px width without scrolling"},
+    "1.4.11": {"name": "Non-text Contrast", "level": "AA", "description": "UI components have contrast ratio of at least 3:1"},
+    "2.1.1": {"name": "Keyboard", "level": "A", "description": "All functionality available from keyboard"},
+    "2.1.2": {"name": "No Keyboard Trap", "level": "A", "description": "Keyboard focus can be moved away from any component"},
+    "2.4.1": {"name": "Bypass Blocks", "level": "A", "description": "Mechanism to bypass blocks of content repeated on pages"},
+    "2.4.2": {"name": "Page Titled", "level": "A", "description": "Pages have descriptive titles"},
+    "2.4.3": {"name": "Focus Order", "level": "A", "description": "Focus order preserves meaning and operability"},
+    "2.4.4": {"name": "Link Purpose", "level": "A", "description": "Purpose of each link can be determined from link text"},
+    "2.4.6": {"name": "Headings and Labels", "level": "AA", "description": "Headings and labels describe topic or purpose"},
+    "2.4.7": {"name": "Focus Visible", "level": "AA", "description": "Keyboard focus indicator is visible"},
+    "2.5.3": {"name": "Label in Name", "level": "A", "description": "Visible label contains accessible name text"},
+    "2.5.5": {"name": "Target Size", "level": "AAA", "description": "Touch target size is at least 44x44 CSS pixels"},
+    "3.1.1": {"name": "Language of Page", "level": "A", "description": "Default human language of Web page can be determined"},
+    "3.1.2": {"name": "Language of Parts", "level": "AA", "description": "Language of each passage can be determined"},
+    "3.2.1": {"name": "On Focus", "level": "A", "description": "Focus does not initiate change of context"},
+    "3.2.2": {"name": "On Input", "level": "A", "description": "Input does not initiate change of context"},
+    "3.3.1": {"name": "Error Identification", "level": "A", "description": "Input errors are automatically detected and described"},
+    "3.3.2": {"name": "Labels or Instructions", "level": "A", "description": "Labels or instructions provided for user input"},
+    "4.1.1": {"name": "Parsing", "level": "A", "description": "Elements have complete start/end tags, no duplicate attributes"},
+    "4.1.2": {"name": "Name, Role, Value", "level": "A", "description": "Name, role, and value can be programmatically determined"},
+    "4.1.3": {"name": "Status Messages", "level": "AA", "description": "Status messages programmatically determined through role"},
+}
+
+
+class AccessibilityTestEngine:
+    """WCAG 2.1 accessibility testing engine"""
+    
+    def __init__(self):
+        self.results: List[Dict] = []
+        self.violations: List[Dict] = []
+    
+    def get_test_suite(self, level: str = "AA") -> List[Dict]:
+        """Get test suite for specified WCAG level"""
+        suite = []
+        valid_levels = {"A", "AA", "AAA"}
+        
+        if level not in valid_levels:
+            level = "AA"
+        
+        for guideline_id, info in WCAG_GUIDELINES.items():
+            if level == "A" and info["level"] == "A":
+                suite.append({"id": guideline_id, **info})
+            elif level == "AA" and info["level"] in ("A", "AA"):
+                suite.append({"id": guideline_id, **info})
+            elif level == "AAA":
+                suite.append({"id": guideline_id, **info})
+        
+        return suite
+    
+    def check_aria_roles(self, page_content: Dict) -> List[Dict]:
+        """Check ARIA roles and attributes"""
+        violations = []
+        
+        # Check buttons have proper roles
+        buttons_without_labels = page_content.get("buttons_without_aria", [])
+        for btn in buttons_without_labels:
+            violations.append({
+                "guideline": "4.1.2",
+                "severity": "critical",
+                "element": btn,
+                "message": "Button lacks accessible name",
+                "fix": "Add aria-label or visible text content",
+            })
+        
+        # Check images have alt text
+        images_without_alt = page_content.get("images_without_alt", [])
+        for img in images_without_alt:
+            violations.append({
+                "guideline": "1.1.1",
+                "severity": "serious",
+                "element": img,
+                "message": "Image missing alt text",
+                "fix": "Add descriptive alt attribute",
+            })
+        
+        return violations
+    
+    def check_color_contrast(self, elements: List[Dict]) -> List[Dict]:
+        """Check color contrast ratios"""
+        violations = []
+        
+        for elem in elements:
+            fg = elem.get("color", "")
+            bg = elem.get("background", "")
+            ratio = self._calculate_contrast_ratio(fg, bg)
+            
+            if ratio < 4.5:  # AA minimum for normal text
+                violations.append({
+                    "guideline": "1.4.3",
+                    "severity": "serious",
+                    "element": elem.get("selector", "unknown"),
+                    "message": f"Contrast ratio {ratio:.1f}:1 is below 4.5:1 minimum",
+                    "fix": "Increase contrast between text and background",
+                    "ratio": ratio,
+                })
+        
+        return violations
+    
+    def check_keyboard_navigation(self, page_content: Dict) -> List[Dict]:
+        """Check keyboard accessibility"""
+        violations = []
+        
+        # Elements that should be keyboard accessible
+        interactive_selectors = [
+            "a[href]", "button", "input", "select", "textarea",
+            "[tabindex]", "[role='button']", "[role='link']",
+        ]
+        
+        non_focusable = page_content.get("non_focusable_interactive", [])
+        for elem in non_focusable:
+            violations.append({
+                "guideline": "2.1.1",
+                "severity": "critical",
+                "element": elem,
+                "message": "Interactive element not keyboard accessible",
+                "fix": "Add tabindex='0' and keyboard event handlers",
+            })
+        
+        return violations
+    
+    def check_heading_hierarchy(self, headings: List[Dict]) -> List[Dict]:
+        """Check heading structure"""
+        violations = []
+        prev_level = 0
+        
+        for heading in headings:
+            level = heading.get("level", 0)
+            
+            if level > prev_level + 1 and prev_level > 0:
+                violations.append({
+                    "guideline": "1.3.1",
+                    "severity": "moderate",
+                    "element": heading.get("selector", ""),
+                    "message": f"Heading level jumps from h{prev_level} to h{level}",
+                    "fix": f"Use h{prev_level + 1} instead of h{level}",
+                })
+            
+            prev_level = level
+        
+        return violations
+    
+    def _calculate_contrast_ratio(self, fg: str, bg: str) -> float:
+        """Calculate WCAG contrast ratio between two colors"""
+        try:
+            fg_lum = self._relative_luminance(fg)
+            bg_lum = self._relative_luminance(bg)
+            
+            lighter = max(fg_lum, bg_lum)
+            darker = min(fg_lum, bg_lum)
+            
+            return (lighter + 0.05) / (darker + 0.05)
+        except Exception:
+            return 0.0
+    
+    def _relative_luminance(self, color: str) -> float:
+        """Calculate relative luminance of a color"""
+        try:
+            if color.startswith("#"):
+                r = int(color[1:3], 16) / 255
+                g = int(color[3:5], 16) / 255
+                b = int(color[5:7], 16) / 255
+            elif color.startswith("rgb"):
+                parts = color.replace("rgb(", "").replace(")", "").split(",")
+                r = int(parts[0].strip()) / 255
+                g = int(parts[1].strip()) / 255
+                b = int(parts[2].strip()) / 255
+            else:
+                return 0.0
+            
+            def linearize(c):
+                return c / 12.92 if c <= 0.03928 else ((c + 0.055) / 1.055) ** 2.4
+            
+            return 0.2126 * linearize(r) + 0.7152 * linearize(g) + 0.0722 * linearize(b)
+        except Exception:
+            return 0.0

nextog/engines/web/browser.py

@@ -0,0 +1,387 @@
+"""
+Web Browser Testing Engine - Playwright-based web testing
+Handles: smoke tests, functional tests, responsive, accessibility, cross-browser
+"""
+
+import asyncio
+from typing import Dict, List, Optional, Any
+from datetime import datetime
+from rich.console import Console
+
+console = Console()
+
+
+class WebTestEngine:
+    """Web testing engine using Playwright"""
+    
+    def __init__(self, settings, db, privacy):
+        self.settings = settings
+        self.db = db
+        self.privacy = privacy
+        self.browser = None
+        self.page = None
+        self.results: Dict[str, Any] = {}
+    
+    async def _setup_browser(self, browser_name: str = "chromium", headless: bool = True):
+        """Initialize browser instance"""
+        try:
+            from playwright.async_api import async_playwright
+            self._playwright = await async_playwright().start()
+            
+            browser_types = {
+                "chromium": self._playwright.chromium,
+                "firefox": self._playwright.firefox,
+                "webkit": self._playwright.webkit,
+            }
+            
+            browser_type = browser_types.get(browser_name, self._playwright.chromium)
+            self.browser = await browser_type.launch(headless=headless)
+            self.page = await self.browser.new_page()
+            
+        except ImportError:
+            console.print("[yellow]⚠ Playwright not installed. Run: playwright install[/yellow]")
+            raise
+    
+    async def _teardown(self):
+        """Clean up browser resources"""
+        if self.browser:
+            await self.browser.close()
+        if hasattr(self, '_playwright') and self._playwright:
+            await self._playwright.stop()
+    
+    def run_tests(self, url: str, browser: str = "chromium", responsive: bool = True,
+                  accessibility: bool = True, performance: bool = False,
+                  coverage_target: int = 90, headless: bool = True) -> Dict:
+        """Run all web tests"""
+        return asyncio.run(self._run_async(
+            url, browser, responsive, accessibility, performance, coverage_target, headless
+        ))
+    
+    async def _run_async(self, url, browser_name, responsive, accessibility,
+                         performance, coverage_target, headless) -> Dict:
+        """Async test execution"""
+        results = {
+            "total": 0,
+            "passed": 0,
+            "failed": 0,
+            "skipped": 0,
+            "coverage": 0,
+            "details": [],
+        }
+        
+        await self._setup_browser(browser_name, headless)
+        
+        try:
+            # Phase 1: Smoke Tests
+            smoke_results = await self._run_smoke_tests(url)
+            results["total"] += smoke_results["total"]
+            results["passed"] += smoke_results["passed"]
+            results["failed"] += smoke_results["failed"]
+            
+            # Phase 2: Functional Tests
+            func_results = await self._run_functional_tests(url)
+            results["total"] += func_results["total"]
+            results["passed"] += func_results["passed"]
+            results["failed"] += func_results["failed"]
+            
+            # Phase 3: Responsive Tests
+            if responsive:
+                resp_results = await self._run_responsive_tests(url)
+                results["total"] += resp_results["total"]
+                results["passed"] += resp_results["passed"]
+                results["failed"] += resp_results["failed"]
+            
+            # Phase 4: Accessibility Tests
+            if accessibility:
+                a11y_results = await self._run_accessibility_tests(url)
+                results["total"] += a11y_results["total"]
+                results["passed"] += a11y_results["passed"]
+                results["failed"] += a11y_results["failed"]
+            
+            # Phase 5: Performance Tests
+            if performance:
+                perf_results = await self._run_performance_tests(url)
+                results["total"] += perf_results["total"]
+                results["passed"] += perf_results["passed"]
+                results["failed"] += perf_results["failed"]
+            
+            # Calculate coverage
+            if results["total"] > 0:
+                results["coverage"] = round((results["passed"] / results["total"]) * 100, 2)
+                results["coverage"] = min(results["coverage"], coverage_target)
+            
+        finally:
+            await self._teardown()
+        
+        # Save to local DB (privacy-first)
+        self.db.save_test_results({"engine": "web", "results": results, "url": url})
+        self.privacy.record_activity("web_test", results)
+        
+        return results
+    
+    async def _run_smoke_tests(self, url: str) -> Dict:
+        """Smoke tests: page loads, basic elements exist"""
+        results = {"total": 0, "passed": 0, "failed": 0}
+        
+        # Test: Page loads
+        results["total"] += 1
+        try:
+            response = await self.page.goto(url, wait_until="networkidle")
+            if response and response.ok:
+                results["passed"] += 1
+            else:
+                results["failed"] += 1
+        except Exception:
+            results["failed"] += 1
+        
+        # Test: Title exists
+        results["total"] += 1
+        try:
+            title = await self.page.title()
+            if title:
+                results["passed"] += 1
+            else:
+                results["failed"] += 1
+        except Exception:
+            results["failed"] += 1
+        
+        # Test: Body exists
+        results["total"] += 1
+        try:
+            body = await self.page.query_selector("body")
+            if body:
+                results["passed"] += 1
+            else:
+                results["failed"] += 1
+        except Exception:
+            results["failed"] += 1
+        
+        # Test: No console errors
+        results["total"] += 1
+        errors = []
+        self.page.on("console", lambda msg: errors.append(msg) if msg.type == "error" else None)
+        await self.page.reload()
+        if len(errors) == 0:
+            results["passed"] += 1
+        else:
+            results["failed"] += 1
+        
+        return results
+    
+    async def _run_functional_tests(self, url: str) -> Dict:
+        """Functional tests: forms, links, navigation"""
+        results = {"total": 0, "passed": 0, "failed": 0}
+        
+        # Test: All links are valid
+        results["total"] += 1
+        try:
+            links = await self.page.query_selector_all("a[href]")
+            broken_links = 0
+            for link in links[:20]:  # Check first 20 links
+                href = await link.get_attribute("href")
+                if href and not href.startswith("#"):
+                    try:
+                        resp = await self.page.request.head(href if href.startswith("http") else f"{url}{href}")
+                        if not resp.ok:
+                            broken_links += 1
+                    except Exception:
+                        broken_links += 1
+            
+            if broken_links == 0:
+                results["passed"] += 1
+            else:
+                results["failed"] += 1
+        except Exception:
+            results["failed"] += 1
+        
+        # Test: Images have alt text
+        results["total"] += 1
+        try:
+            images = await self.page.query_selector_all("img")
+            missing_alt = 0
+            for img in images:
+                alt = await img.get_attribute("alt")
+                if not alt:
+                    missing_alt += 1
+            
+            if missing_alt == 0:
+                results["passed"] += 1
+            else:
+                results["failed"] += 1
+        except Exception:
+            results["failed"] += 1
+        
+        # Test: Forms are functional
+        results["total"] += 1
+        try:
+            forms = await self.page.query_selector_all("form")
+            all_valid = True
+            for form in forms:
+                action = await form.get_attribute("action")
+                method = await form.get_attribute("method")
+                if not action:
+                    all_valid = False
+            
+            if all_valid:
+                results["passed"] += 1
+            else:
+                results["failed"] += 1
+        except Exception:
+            results["failed"] += 1
+        
+        # Test: Navigation works
+        results["total"] += 1
+        try:
+            nav_links = await self.page.query_selector_all("nav a, header a")
+            if len(nav_links) > 0:
+                results["passed"] += 1
+            else:
+                results["failed"] += 1
+        except Exception:
+            results["failed"] += 1
+        
+        return results
+    
+    async def _run_responsive_tests(self, url: str) -> Dict:
+        """Responsive design tests across viewports"""
+        results = {"total": 0, "passed": 0, "failed": 0}
+        
+        viewports = [
+            ("Mobile", 375, 667),
+            ("Tablet", 768, 1024),
+            ("Desktop", 1920, 1080),
+            ("Wide", 2560, 1440),
+        ]
+        
+        for name, width, height in viewports:
+            results["total"] += 1
+            try:
+                await self.page.set_viewport_size({"width": width, "height": height})
+                await self.page.goto(url, wait_until="networkidle")
+                
+                # Check no horizontal scroll
+                has_hscroll = await self.page.evaluate("""
+                    () => document.documentElement.scrollWidth > document.documentElement.clientWidth
+                """)
+                
+                if not has_hscroll:
+                    results["passed"] += 1
+                else:
+                    results["failed"] += 1
+            except Exception:
+                results["failed"] += 1
+        
+        return results
+    
+    async def _run_accessibility_tests(self, url: str) -> Dict:
+        """Accessibility (WCAG) tests"""
+        results = {"total": 0, "passed": 0, "failed": 0}
+        
+        await self.page.goto(url, wait_until="networkidle")
+        
+        # Test: ARIA labels
+        results["total"] += 1
+        try:
+            aria_issues = await self.page.evaluate("""
+                () => {
+                    const buttons = document.querySelectorAll('button:not([aria-label]):not([aria-labelledby])');
+                    const inputs = document.querySelectorAll('input:not([aria-label]):not([labelledby])');
+                    return buttons.length + inputs.length;
+                }
+            """)
+            if aria_issues == 0:
+                results["passed"] += 1
+            else:
+                results["failed"] += 1
+        except Exception:
+            results["failed"] += 1
+        
+        # Test: Color contrast (basic check)
+        results["total"] += 1
+        try:
+            contrast_ok = await self.page.evaluate("""
+                () => {
+                    const elements = document.querySelectorAll('p, h1, h2, h3, span, a');
+                    let issues = 0;
+                    elements.forEach(el => {
+                        const style = getComputedStyle(el);
+                        const color = style.color;
+                        const bg = style.backgroundColor;
+                        if (color === bg) issues++;
+                    });
+                    return issues;
+                }
+            """)
+            if contrast_ok == 0:
+                results["passed"] += 1
+            else:
+                results["failed"] += 1
+        except Exception:
+            results["failed"] += 1
+        
+        # Test: Heading hierarchy
+        results["total"] += 1
+        try:
+            heading_ok = await self.page.evaluate("""
+                () => {
+                    const headings = document.querySelectorAll('h1, h2, h3, h4, h5, h6');
+                    let prev = 0;
+                    for (const h of headings) {
+                        const level = parseInt(h.tagName[1]);
+                        if (level > prev + 1 && prev > 0) return false;
+                        prev = level;
+                    }
+                    return true;
+                }
+            """)
+            if heading_ok:
+                results["passed"] += 1
+            else:
+                results["failed"] += 1
+        except Exception:
+            results["failed"] += 1
+        
+        return results
+    
+    async def _run_performance_tests(self, url: str) -> Dict:
+        """Performance and load time tests"""
+        results = {"total": 0, "passed": 0, "failed": 0}
+        
+        # Test: Page load time
+        results["total"] += 1
+        try:
+            import time
+            start = time.time()
+            await self.page.goto(url, wait_until="networkidle")
+            load_time = time.time() - start
+            
+            if load_time < 5:  # Under 5 seconds
+                results["passed"] += 1
+            else:
+                results["failed"] += 1
+        except Exception:
+            results["failed"] += 1
+        
+        # Test: Core Web Vitals
+        results["total"] += 1
+        try:
+            metrics = await self.page.evaluate("""
+                () => {
+                    const timing = performance.timing;
+                    const domReady = timing.domContentLoadedEventEnd - timing.navigationStart;
+                    const loadComplete = timing.loadEventEnd - timing.navigationStart;
+                    return { domReady, loadComplete };
+                }
+            """)
+            if metrics.get("domReady", 99999) < 3000:
+                results["passed"] += 1
+            else:
+                results["failed"] += 1
+        except Exception:
+            results["failed"] += 1
+        
+        return results
+    
+    def execute_phase(self, phase: str) -> Dict:
+        """Execute a specific phase (called by TestEngine)"""
+        return {"total": 0, "passed": 0, "failed": 0, "skipped": 0}