patchi 0.7.5__py3-none-any.whl

patchi/core/testing/live_test_runner.py

@@ -0,0 +1,304 @@
+"""
+LiveTestRunner — Orchestrates all test agents and streams results live.
+
+Manages the full test lifecycle:
+1. Discovers which agents to run based on test type
+2. Executes agents sequentially (or parallel for independent ones)
+3. Streams real-time results via WebSocket events
+4. Generates summary report
+5. Saves results to memory for historical tracking
+
+This is the bridge between the CLI test command, web UI, and test agents.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from ..agents.base import AgentGroup, AgentInput, AgentResult, AgentStatus
+
+_log = logging.getLogger("patchi.testing.live_test_runner")
+
+
+@dataclass
+class TestRunConfig:
+    """Configuration for a test run."""
+
+    test_types: list[str] = field(default_factory=lambda: ["unit", "regression"])
+    area: str | None = None
+    base_url: str | None = None
+    parallel: bool = False
+    timeout_per_agent: int = 120
+    on_event: Callable | None = None  # async callback for live streaming
+
+
+@dataclass
+class TestRunResult:
+    """Aggregated result of a full test run."""
+
+    started_at: float = 0
+    completed_at: float = 0
+    total_duration_ms: int = 0
+    agents_run: list[str] = field(default_factory=list)
+    results: list[AgentResult] = field(default_factory=list)
+    total_findings: int = 0
+    total_passed: int = 0
+    total_failed: int = 0
+    summary: dict = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        return {
+            "started_at": self.started_at,
+            "completed_at": self.completed_at,
+            "total_duration_ms": self.total_duration_ms,
+            "agents_run": self.agents_run,
+            "total_findings": self.total_findings,
+            "total_passed": self.total_passed,
+            "total_failed": self.total_failed,
+            "summary": self.summary,
+            "results": [r.to_dict() for r in self.results],
+        }
+
+
+# Map of test type names to agent class names
+TEST_TYPE_MAP = {
+    "unit": ["UnitTestAgent"],
+    "regression": ["RegressionAgent"],
+    "browser": ["BrowserTestAgent"],
+    "stress": ["StressTestAgent"],
+    "accessibility": ["UIAccessibilityAgent"],
+    "api": ["APIContractAgent"],
+    "buttons": ["UIButtonAgent"],
+    "layout": ["UILayoutAgent"],
+    "e2e": ["E2EFlowAgent"],
+    "visual": ["VisualRegressionAgent"],
+    "smoke": ["UIButtonAgent", "UILayoutAgent", "UIAccessibilityAgent"],
+    "full": [
+        "UnitTestAgent",
+        "RegressionAgent",
+        "UIButtonAgent",
+        "UIAccessibilityAgent",
+        "UILayoutAgent",
+        "E2EFlowAgent",
+        "VisualRegressionAgent",
+    ],
+}
+
+
+class LiveTestRunner:
+    """Orchestrates test execution and streams live results."""
+
+    def __init__(self, root: Path):
+        self.root = root
+        self._event_queue: asyncio.Queue | None = None
+        self._event_callback: Callable | None = None
+
+    async def run(self, config: TestRunConfig) -> TestRunResult:
+        """Execute a full test run with live event streaming."""
+        # Import test agents to trigger registration
+        import patchi.core.testing.test_agents  # noqa
+        import patchi.core.testing.ui_button_agent  # noqa
+        import patchi.core.testing.ui_accessibility_agent  # noqa
+        import patchi.core.testing.ui_layout_agent  # noqa
+        import patchi.core.testing.e2e_flow_agent  # noqa
+        import patchi.core.testing.visual_regression_agent  # noqa
+
+        from ..agents.base import get_agent
+
+        result = TestRunResult(started_at=time.time())
+
+        # Resolve which agents to run
+        agent_names = self._resolve_agents(config.test_types)
+        result.agents_run = agent_names
+
+        # Load brain and config
+        from .. import config as cfg
+        from .. import memory as mem
+
+        brain = mem.get_brain(self.root)
+        try:
+            app_config = cfg.load(self.root)
+        except Exception as e:
+            _log.warning("LiveTestRunner.run failed: %s", e)
+            app_config = {}
+
+        # Determine scope
+        scope = []
+        if config.area:
+            area_path = self.root / config.area
+            if area_path.is_dir():
+                scope = [str(p.relative_to(self.root)) for p in area_path.rglob("*.py")]
+
+        # Fire start event
+        await self._emit(
+            "test_run_started",
+            {
+                "agents": agent_names,
+                "test_types": config.test_types,
+                "area": config.area,
+            },
+        )
+
+        # Run agents
+        for agent_name in agent_names:
+            agent_cls = get_agent(agent_name)
+            if not agent_cls:
+                continue
+
+            await self._emit(
+                "agent_started",
+                {
+                    "agent": agent_name,
+                    "description": agent_cls.description
+                    if hasattr(agent_cls, "description")
+                    else "",
+                },
+            )
+
+            t0 = time.monotonic()
+            try:
+                inp = AgentInput(
+                    root=self.root,
+                    scope=scope,
+                    brain=brain,
+                    config=app_config,
+                    extra={"base_url": config.base_url} if config.base_url else {},
+                )
+                agent = agent_cls()
+                agent_result = await asyncio.to_thread(agent.run, inp)
+            except Exception as e:
+                agent_result = AgentResult(
+                    agent_name=agent_name,
+                    agent_group=AgentGroup.TEST,
+                    status=AgentStatus.FAILED,
+                )
+                agent_result.add_error(str(e))
+
+            agent_result.duration_ms = int((time.monotonic() - t0) * 1000)
+            result.results.append(agent_result)
+
+            # Count findings
+            result.total_findings += agent_result.finding_count
+
+            # Count passed/failed from suite data
+            suite = agent_result.data.get("suite", {})
+            result.total_passed += suite.get("passed", 0)
+            result.total_failed += suite.get("failed", 0)
+
+            # Fire agent done event
+            await self._emit(
+                "agent_done",
+                {
+                    "agent": agent_name,
+                    "status": agent_result.status.value,
+                    "finding_count": agent_result.finding_count,
+                    "duration_ms": agent_result.duration_ms,
+                    "passed": suite.get("passed", 0),
+                    "failed": suite.get("failed", 0),
+                },
+            )
+
+            # Fire individual findings
+            for finding in agent_result.findings:
+                await self._emit(
+                    "agent_finding",
+                    {
+                        "agent": agent_name,
+                        "severity": finding.severity.value,
+                        "type": finding.type,
+                        "message": finding.message,
+                        "file": finding.file,
+                    },
+                )
+
+        result.completed_at = time.time()
+        result.total_duration_ms = int((result.completed_at - result.started_at) * 1000)
+
+        # Build summary
+        result.summary = self._build_summary(result)
+
+        # Fire completion event
+        await self._emit("test_run_completed", result.summary)
+
+        # Save to memory
+        self._save_results(result)
+
+        return result
+
+    def _resolve_agents(self, test_types: list[str]) -> list[str]:
+        """Resolve test type names to agent class names."""
+        agents = []
+        for t in test_types:
+            t_lower = t.lower()
+            if t_lower in TEST_TYPE_MAP:
+                agents.extend(TEST_TYPE_MAP[t_lower])
+            else:
+                # Try direct agent name
+                from ..agents.base import get_agent
+
+                if get_agent(t):
+                    agents.append(t)
+        return list(dict.fromkeys(agents))  # dedupe preserving order
+
+    def _build_summary(self, result: TestRunResult) -> dict:
+        """Build a summary of the test run."""
+        by_status = {}
+        by_severity = {"critical": 0, "high": 0, "medium": 0, "low": 0, "info": 0}
+
+        for r in result.results:
+            status = r.status.value
+            by_status[status] = by_status.get(status, 0) + 1
+            for f in r.findings:
+                sev = f.severity.value
+                by_severity[sev] = by_severity.get(sev, 0) + 1
+
+        all_passed = by_status.get("failed", 0) == 0 and by_status.get("skipped", 0) == 0
+
+        return {
+            "total_agents": len(result.results),
+            "by_status": by_status,
+            "by_severity": by_severity,
+            "total_findings": result.total_findings,
+            "total_passed": result.total_passed,
+            "total_failed": result.total_failed,
+            "all_passed": all_passed,
+            "duration_ms": result.total_duration_ms,
+        }
+
+    def _save_results(self, result: TestRunResult) -> None:
+        """Save test results to memory for historical tracking."""
+        try:
+            from .. import memory as mem
+
+            scan_data = {
+                "status": "done" if result.summary.get("all_passed") else "failed",
+                "duration_ms": result.total_duration_ms,
+                "finding_count": result.total_findings,
+                "passed": result.total_passed,
+                "failed": result.total_failed,
+                "agents": result.agents_run,
+                "summary": result.summary,
+            }
+            mem.save_scan_result("TestRunner", scan_data, self.root)
+        except Exception as e:
+            _log.warning("LiveTestRunner._save_results failed: %s", e)
+
+    async def _emit(self, event: str, data: dict) -> None:
+        """Emit a live event for WebSocket streaming."""
+        if self._event_queue:
+            await self._event_queue.put({"event": event, "data": data, "ts": time.time()})
+
+        if self._event_callback:
+            try:
+                await self._event_callback(event, data)
+            except Exception as e:
+                _log.debug("LiveTestRunner._emit failed: %s", e)
+
+    def set_event_callback(self, callback: Callable) -> None:
+        """Set an async callback for live event streaming."""
+        self._event_callback = callback

patchi/core/testing/live_v2/__init__.py

@@ -0,0 +1 @@
+"""Live testing v2: browser pool, stress orchestration, screenshots, video recording."""

patchi/core/testing/live_v2/browser_pool.py

@@ -0,0 +1,349 @@
+"""
+Browser Pool — Manages browser instances for parallel testing.
+
+Features:
+- Pool of reusable browser contexts
+- Automatic lifecycle management
+- Resource limits (max browsers, max pages per browser)
+- Health checks and auto-recovery
+- Support for Chrome, Firefox, WebKit
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from dataclasses import dataclass, field
+from typing import Any
+
+_log = logging.getLogger("patchi.testing.browser_pool")
+
+
+@dataclass
+class BrowserInstance:
+    """A single browser instance in the pool."""
+
+    id: str
+    browser_type: str  # "chromium", "firefox", "webkit"
+    created_at: float
+    last_used: float
+    page_count: int = 0
+    healthy: bool = True
+    _browser: Any = None  # Playwright browser
+    _context: Any = None  # Browser context
+
+
+@dataclass
+class BrowserConfig:
+    """Configuration for browser pool."""
+
+    max_browsers: int = 5
+    max_pages_per_browser: int = 10
+    browser_type: str = "chromium"  # chromium, firefox, webkit
+    headless: bool = True
+    viewport: dict = field(default_factory=lambda: {"width": 1280, "height": 720})
+    default_timeout: int = 30000  # ms
+    launch_args: list[str] = field(
+        default_factory=lambda: [
+            "--no-sandbox",
+            "--disable-setuid-sandbox",
+            "--disable-dev-shm-usage",
+            "--disable-gpu",
+        ]
+    )
+    # Stealth settings
+    stealth: bool = False
+    user_agent: str | None = None
+
+
+class BrowserPool:
+    """
+    Manages a pool of browser instances for parallel test execution.
+
+    Usage:
+        pool = BrowserPool(config)
+        await pool.initialize()
+
+        # Get a page for testing
+        page = await pool.get_page()
+        try:
+            await page.goto("https://example.com")
+            # ... test actions
+        finally:
+            await pool.release_page(page)
+
+        await pool.shutdown()
+    """
+
+    def __init__(self, config: BrowserConfig = None):
+        self.config = config or BrowserConfig()
+        self._browsers: dict[str, BrowserInstance] = {}
+        self._playwright = None
+        self._initialized = False
+        self._lock = asyncio.Lock()
+        self._stats = {
+            "total_created": 0,
+            "total_reused": 0,
+            "total_failed": 0,
+            "current_active": 0,
+        }
+
+    async def initialize(self):
+        """Initialize the browser pool."""
+        if self._initialized:
+            return
+
+        try:
+            from playwright.async_api import async_playwright
+
+            self._playwright = await async_playwright().start()
+            self._initialized = True
+            _log.info(f"Browser pool initialized ({self.config.browser_type})")
+        except ImportError:
+            _log.error(
+                "Playwright not installed. "
+                "Install with: pip install playwright && playwright install"
+            )
+            raise
+        except Exception as e:
+            _log.error(f"Failed to initialize browser pool: {e}")
+            raise
+
+    async def get_page(self) -> Any:
+        """Get a browser page from the pool."""
+        async with self._lock:
+            # Try to reuse existing browser
+            for browser in self._browsers.values():
+                if browser.healthy and browser.page_count < self.config.max_pages_per_browser:
+                    browser.page_count += 1
+                    browser.last_used = time.time()
+                    self._stats["total_reused"] += 1
+                    self._stats["current_active"] += 1
+                    return await browser._context.new_page()
+
+            # Create new browser if under limit
+            if len(self._browsers) < self.config.max_browsers:
+                return await self._create_browser_and_page()
+
+            # Wait for available browser
+            while True:
+                for browser in self._browsers.values():
+                    if browser.healthy and browser.page_count < self.config.max_pages_per_browser:
+                        browser.page_count += 1
+                        browser.last_used = time.time()
+                        self._stats["total_reused"] += 1
+                        self._stats["current_active"] += 1
+                        return await browser._context.new_page()
+                await asyncio.sleep(0.1)
+
+    async def _create_browser_and_page(self) -> Any:
+        """Create a new browser instance and return a page."""
+        browser_type = getattr(self._playwright, self.config.browser_type)
+
+        # Launch browser
+        browser = await browser_type.launch(
+            headless=self.config.headless,
+            args=self.config.launch_args,
+        )
+
+        # Create context
+        context = await browser.new_context(
+            viewport=self.config.viewport,
+            user_agent=self.config.user_agent,
+        )
+
+        # Apply stealth if enabled
+        if self.config.stealth:
+            await self._apply_stealth(context)
+
+        # Create instance record
+        instance_id = f"{self.config.browser_type}-{len(self._browsers)}"
+        instance = BrowserInstance(
+            id=instance_id,
+            browser_type=self.config.browser_type,
+            created_at=time.time(),
+            last_used=time.time(),
+            page_count=1,
+            _browser=browser,
+            _context=context,
+        )
+
+        self._browsers[instance_id] = instance
+        self._stats["total_created"] += 1
+        self._stats["current_active"] += 1
+
+        _log.debug(f"Created new browser: {instance_id}")
+
+        # Return first page
+        page = await context.new_page()
+        page.set_default_timeout(self.config.default_timeout)
+        return page
+
+    async def _apply_stealth(self, context: Any):
+        """Apply stealth settings to avoid detection."""
+        await context.add_init_script("""
+            // Remove webdriver property
+            Object.defineProperty(navigator, 'webdriver', {get: () => undefined});
+
+            // Mock permissions
+            const originalQuery = window.navigator.permissions.query;
+            window.navigator.permissions.query = (parameters) => (
+                parameters.name === 'notifications' ?
+                    Promise.resolve({ state: Notification.permission }) :
+                    originalQuery(parameters)
+            );
+        """)
+
+    async def release_page(self, page: Any):
+        """Release a page back to the pool."""
+        async with self._lock:
+            self._stats["current_active"] = max(0, self._stats["current_active"] - 1)
+
+            # Find which browser this page belongs to
+            for browser in self._browsers.values():
+                # This is a simplification - in reality we'd track page->browser mapping
+                if browser.page_count > 0:
+                    browser.page_count -= 1
+                    break
+
+            try:
+                await page.close()
+            except Exception as e:
+                _log.debug(f"Error closing page: {e}")
+
+    async def get_browser_for_recording(self, video_dir: str | None = None) -> tuple[Any, BrowserInstance]:
+        """Get a dedicated browser for video recording.
+
+        Args:
+            video_dir: Directory to save video recordings.
+                       Defaults to .patchi/evidence/video/ if not specified.
+        """
+        import os
+        from pathlib import Path
+
+        async with self._lock:
+            # Resolve video directory
+            if video_dir is None:
+                video_dir = str(Path.cwd() / ".patchi" / "evidence" / "video")
+            os.makedirs(video_dir, exist_ok=True)
+
+            # Create a fresh browser for recording
+            browser_type = getattr(self._playwright, self.config.browser_type)
+            browser = await browser_type.launch(
+                headless=self.config.headless,
+                args=self.config.launch_args,
+            )
+            context = await browser.new_context(
+                viewport=self.config.viewport,
+                record_video_dir=video_dir,
+                record_video_size=self.config.viewport,
+            )
+
+            instance_id = f"recording-{int(time.time())}"
+            instance = BrowserInstance(
+                id=instance_id,
+                browser_type=self.config.browser_type,
+                created_at=time.time(),
+                last_used=time.time(),
+                page_count=1,
+                _browser=browser,
+                _context=context,
+            )
+
+            self._browsers[instance_id] = instance
+            return context, instance
+
+    async def health_check(self) -> dict:
+        """Check health of all browsers in pool."""
+        healthy = 0
+        unhealthy = 0
+
+        for instance in list(self._browsers.values()):
+            try:
+                # Try to create a test page
+                page = await instance._context.new_page()
+                await page.close()
+                instance.healthy = True
+                healthy += 1
+            except Exception:
+                instance.healthy = False
+                unhealthy += 1
+
+        return {
+            "total": len(self._browsers),
+            "healthy": healthy,
+            "unhealthy": unhealthy,
+            "stats": self._stats,
+        }
+
+    async def cleanup_idle(self, max_idle_seconds: int = 300):
+        """Clean up idle browsers."""
+        async with self._lock:
+            now = time.time()
+            to_remove = []
+
+            for instance_id, instance in self._browsers.items():
+                if instance.page_count == 0 and (now - instance.last_used) > max_idle_seconds:
+                    to_remove.append(instance_id)
+
+            for instance_id in to_remove:
+                instance = self._browsers.pop(instance_id)
+                try:
+                    await instance._context.close()
+                    await instance._browser.close()
+                except Exception as _exc:
+                    _log.warning('cleanup_idle failed: %s', _exc)
+                _log.debug(f"Cleaned up idle browser: {instance_id}")
+
+    async def shutdown(self):
+        """Shutdown all browsers and playwright."""
+        async with self._lock:
+            for instance in self._browsers.values():
+                try:
+                    await instance._context.close()
+                    await instance._browser.close()
+                except Exception as _exc:
+                    _log.warning('shutdown failed: %s', _exc)
+
+            self._browsers.clear()
+
+            if self._playwright:
+                await self._playwright.stop()
+                self._playwright = None
+
+            self._initialized = False
+            _log.info("Browser pool shut down")
+
+    def get_stats(self) -> dict:
+        """Get pool statistics."""
+        return {
+            **self._stats,
+            "browser_count": len(self._browsers),
+            "config": {
+                "max_browsers": self.config.max_browsers,
+                "max_pages_per_browser": self.config.max_pages_per_browser,
+                "browser_type": self.config.browser_type,
+            },
+        }
+
+
+# Global pool instance
+_browser_pool: BrowserPool | None = None
+
+
+async def get_browser_pool(config: BrowserConfig = None) -> BrowserPool:
+    """Get or create the global browser pool."""
+    global _browser_pool
+    if _browser_pool is None or not _browser_pool._initialized:
+        _browser_pool = BrowserPool(config)
+        await _browser_pool.initialize()
+    return _browser_pool
+
+
+async def shutdown_browser_pool():
+    """Shutdown the global browser pool."""
+    global _browser_pool
+    if _browser_pool:
+        await _browser_pool.shutdown()
+        _browser_pool = None