scitex 2.4.2__py3-none-any.whl → 2.4.3__py3-none-any.whl

scitex/browser/debugging/_sync_session.py

@@ -0,0 +1,259 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: 2025-12-08
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/browser/debugging/_sync_session.py
+
+"""
+Sync browser session context manager for pytest-playwright E2E tests.
+
+Ensures proper cleanup of browser processes to prevent zombies.
+
+Usage in conftest.py:
+    from scitex.browser import SyncBrowserSession
+
+    @pytest.fixture
+    def browser_session(page: Page):
+        with SyncBrowserSession(page) as session:
+            yield session
+        # Cleanup happens automatically even on exceptions
+
+Or use the fixture factory:
+    from scitex.browser import create_browser_session_fixture
+    browser_session = create_browser_session_fixture()
+"""
+
+import atexit
+import os
+import signal
+import subprocess
+from contextlib import contextmanager
+from typing import TYPE_CHECKING, Callable, Optional
+
+if TYPE_CHECKING:
+    from playwright.sync_api import Page
+
+
+class SyncBrowserSession:
+    """
+    Sync context manager for playwright browser sessions.
+
+    Ensures zombie process cleanup on test failures, timeouts, or crashes.
+    Tracks browser PIDs and kills orphaned processes on exit.
+    """
+
+    # Class-level tracking of active sessions for emergency cleanup
+    _active_sessions: list["SyncBrowserSession"] = []
+    _cleanup_registered = False
+
+    def __init__(
+        self,
+        page: "Page",
+        timeout: int = 60,
+        on_enter: Optional[Callable[["Page"], None]] = None,
+        on_exit: Optional[Callable[["Page", bool], None]] = None,
+    ):
+        """
+        Initialize sync browser session.
+
+        Args:
+            page: Playwright page instance from pytest-playwright
+            timeout: Default timeout for operations in seconds
+            on_enter: Callback when entering context
+            on_exit: Callback when exiting context (receives page and success flag)
+        """
+        self.page = page
+        self.timeout = timeout
+        self.on_enter = on_enter
+        self.on_exit = on_exit
+        self._browser_pid = None
+        self._context_pid = None
+        self._success = True
+
+        # Register class-level emergency cleanup
+        if not SyncBrowserSession._cleanup_registered:
+            atexit.register(SyncBrowserSession._emergency_cleanup)
+            SyncBrowserSession._cleanup_registered = True
+
+    def __enter__(self) -> "SyncBrowserSession":
+        """Enter context - track browser PIDs and run setup callback."""
+        # Track this session
+        SyncBrowserSession._active_sessions.append(self)
+
+        # Try to get browser PID for tracking
+        try:
+            if self.page.context.browser:
+                # Get the browser process
+                browser = self.page.context.browser
+                # Browser PID is available via internal _impl
+                if hasattr(browser, '_impl'):
+                    impl = browser._impl
+                    if hasattr(impl, '_process'):
+                        self._browser_pid = impl._process.pid
+        except Exception:
+            pass  # PID tracking is best-effort
+
+        # Run setup callback
+        if self.on_enter:
+            self.on_enter(self.page)
+
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> bool:
+        """Exit context - ensure cleanup happens."""
+        self._success = exc_type is None
+
+        # Remove from active sessions
+        try:
+            SyncBrowserSession._active_sessions.remove(self)
+        except ValueError:
+            pass
+
+        # Run exit callback
+        if self.on_exit:
+            try:
+                self.on_exit(self.page, self._success)
+            except Exception:
+                pass  # Don't fail on callback errors
+
+        # If there was an exception, try to close gracefully
+        if exc_type is not None:
+            try:
+                self.page.close()
+            except Exception:
+                pass
+
+            try:
+                self.page.context.close()
+            except Exception:
+                pass
+
+        # Kill orphaned browser process if we have the PID
+        if self._browser_pid and not self._success:
+            self._kill_process_tree(self._browser_pid)
+
+        # Don't suppress the exception
+        return False
+
+    @staticmethod
+    def _kill_process_tree(pid: int):
+        """Kill a process and all its children (zombies)."""
+        try:
+            # Try SIGTERM first
+            os.kill(pid, signal.SIGTERM)
+        except ProcessLookupError:
+            return  # Already dead
+        except PermissionError:
+            return  # Can't kill
+
+        # Give it a moment
+        import time
+        time.sleep(0.5)
+
+        # Force kill if still running
+        try:
+            os.kill(pid, signal.SIGKILL)
+        except (ProcessLookupError, PermissionError):
+            pass
+
+    @classmethod
+    def _emergency_cleanup(cls):
+        """Emergency cleanup of all active sessions on process exit."""
+        for session in cls._active_sessions[:]:  # Copy list to avoid mutation
+            if session._browser_pid:
+                cls._kill_process_tree(session._browser_pid)
+        cls._active_sessions.clear()
+
+    @staticmethod
+    def kill_zombie_browsers():
+        """Kill all zombie chromium/chrome processes from failed tests.
+
+        Call this at the start of test sessions to clean up from previous runs.
+        """
+        try:
+            # Find orphaned chromium processes
+            result = subprocess.run(
+                ["pgrep", "-f", "chromium|chrome"],
+                capture_output=True,
+                text=True,
+            )
+            if result.returncode == 0:
+                pids = result.stdout.strip().split('\n')
+                for pid in pids:
+                    if pid:
+                        try:
+                            os.kill(int(pid), signal.SIGKILL)
+                        except (ProcessLookupError, PermissionError, ValueError):
+                            pass
+        except FileNotFoundError:
+            pass  # pgrep not available
+
+
+@contextmanager
+def sync_browser_session(
+    page: "Page",
+    timeout: int = 60,
+    on_enter: Optional[Callable[["Page"], None]] = None,
+    on_exit: Optional[Callable[["Page", bool], None]] = None,
+):
+    """
+    Context manager for sync playwright sessions.
+
+    Usage:
+        with sync_browser_session(page) as session:
+            session.page.goto(url)
+            # ... test code
+        # Cleanup happens automatically
+    """
+    session = SyncBrowserSession(page, timeout, on_enter, on_exit)
+    with session:
+        yield session
+
+
+def create_browser_session_fixture(
+    timeout: int = 60,
+    setup: Optional[Callable[["Page"], None]] = None,
+    teardown: Optional[Callable[["Page", bool], None]] = None,
+    kill_zombies_on_start: bool = True,
+):
+    """
+    Create a pytest fixture for browser session with cleanup.
+
+    Usage in conftest.py:
+        from scitex.browser import create_browser_session_fixture
+
+        browser_session = create_browser_session_fixture(
+            timeout=60,
+            setup=lambda page: print(f"Starting test"),
+            teardown=lambda page, success: print(f"Test {'passed' if success else 'failed'}"),
+            kill_zombies_on_start=True,
+        )
+
+    Args:
+        timeout: Default timeout for operations
+        setup: Callback when entering session
+        teardown: Callback when exiting (receives page and success flag)
+        kill_zombies_on_start: Kill orphaned browsers before first test
+
+    Returns:
+        A pytest fixture function
+    """
+    import pytest
+
+    _zombies_cleaned = False
+
+    @pytest.fixture
+    def browser_session(page: "Page"):
+        nonlocal _zombies_cleaned
+
+        # Clean up zombies from previous runs (once per session)
+        if kill_zombies_on_start and not _zombies_cleaned:
+            SyncBrowserSession.kill_zombie_browsers()
+            _zombies_cleaned = True
+
+        with SyncBrowserSession(page, timeout, setup, teardown) as session:
+            yield session
+
+    return browser_session
+
+
+# EOF

scitex/browser/debugging/_test_monitor.py

@@ -0,0 +1,284 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: 2025-12-08
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/browser/debugging/_test_monitor.py
+
+"""
+Test monitoring with periodic screenshots using scitex.capture.
+
+Provides automated visual monitoring during E2E tests:
+- Periodic screenshots at configurable intervals
+- Integration with scitex.capture for WSL/Windows support
+- GIF generation from test sessions
+- Pytest fixture integration
+
+Usage in conftest.py:
+    from scitex.browser.debugging import (
+        create_test_monitor,
+        TestMonitor,
+    )
+
+    @pytest.fixture
+    def test_monitor():
+        monitor = TestMonitor(interval=2.0, verbose=True)
+        monitor.start()
+        yield monitor
+        monitor.stop()
+        monitor.create_gif()  # Optional: create GIF from screenshots
+"""
+
+from datetime import datetime
+from pathlib import Path
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from playwright.sync_api import Page
+
+
+class TestMonitor:
+    """
+    Monitor E2E tests with periodic screenshots using scitex.capture.
+
+    Captures screenshots at regular intervals during test execution,
+    allowing visual inspection of test progress and debugging.
+    """
+
+    def __init__(
+        self,
+        output_dir: str | Path = None,
+        interval: float = 2.0,
+        quality: int = 70,
+        verbose: bool = False,
+        test_name: str = None,
+    ):
+        """
+        Initialize test monitor.
+
+        Args:
+            output_dir: Directory for screenshots (default: ~/.scitex/test_monitor)
+            interval: Seconds between screenshots (default: 2.0)
+            quality: JPEG quality 1-100 (default: 70)
+            verbose: Print capture messages
+            test_name: Optional test name for session identification
+        """
+        self.output_dir = Path(output_dir or Path.home() / ".scitex" / "test_monitor")
+        self.interval = interval
+        self.quality = quality
+        self.verbose = verbose
+        self.test_name = test_name
+        self.session_id = None
+        self._worker = None
+        self._capture_manager = None
+
+    def start(self, test_name: str = None) -> str:
+        """
+        Start periodic screenshot capture.
+
+        Args:
+            test_name: Optional test name to include in session
+
+        Returns:
+            Session ID for this capture session
+        """
+        try:
+            from scitex.capture import CaptureManager
+        except ImportError:
+            if self.verbose:
+                print("[TestMonitor] scitex.capture not available")
+            return None
+
+        # Generate session ID
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        name = test_name or self.test_name or "test"
+        safe_name = name.replace("::", "_").replace("[", "_").replace("]", "").replace("/", "_")
+        self.session_id = f"{timestamp}_{safe_name}"
+
+        # Create session directory
+        session_dir = self.output_dir / self.session_id
+        session_dir.mkdir(parents=True, exist_ok=True)
+
+        # Start capture
+        self._capture_manager = CaptureManager()
+        self._worker = self._capture_manager.start_capture(
+            output_dir=str(session_dir),
+            interval=self.interval,
+            jpeg=True,
+            quality=self.quality,
+            verbose=self.verbose,
+        )
+
+        if self.verbose:
+            print(f"[TestMonitor] Started: {session_dir} (interval: {self.interval}s)")
+
+        return self.session_id
+
+    def stop(self) -> dict:
+        """
+        Stop screenshot capture.
+
+        Returns:
+            Status dict with session info
+        """
+        if self._capture_manager:
+            self._capture_manager.stop_capture()
+
+        status = self.get_status()
+
+        if self.verbose and self._worker:
+            print(f"[TestMonitor] Stopped: {self._worker.screenshot_count} screenshots")
+
+        return status
+
+    def get_status(self) -> dict:
+        """Get current monitor status."""
+        if self._worker:
+            return self._worker.get_status()
+        return {
+            "running": False,
+            "session_id": self.session_id,
+            "output_dir": str(self.output_dir),
+        }
+
+    def take_snapshot(self, message: str = None) -> Optional[str]:
+        """
+        Take an immediate snapshot (in addition to periodic captures).
+
+        Args:
+            message: Optional message to include in filename
+
+        Returns:
+            Path to saved screenshot
+        """
+        try:
+            from scitex.capture import snap
+            return snap(message=message, output_dir=str(self.output_dir))
+        except ImportError:
+            return None
+
+    def create_gif(self, duration: float = 0.5, output_path: str = None) -> Optional[str]:
+        """
+        Create GIF from captured screenshots.
+
+        Args:
+            duration: Duration per frame in seconds
+            output_path: Output path for GIF (auto-generated if None)
+
+        Returns:
+            Path to created GIF
+        """
+        if not self.session_id:
+            return None
+
+        try:
+            from scitex.capture import create_gif_from_session
+
+            session_dir = self.output_dir / self.session_id
+            if output_path is None:
+                output_path = str(session_dir / f"{self.session_id}.gif")
+
+            return create_gif_from_session(
+                session_id=self.session_id,
+                output_path=output_path,
+                duration=duration,
+            )
+        except ImportError:
+            if self.verbose:
+                print("[TestMonitor] GIF creation requires scitex.capture")
+            return None
+
+    def get_screenshots(self) -> list:
+        """Get list of captured screenshot paths."""
+        if not self.session_id:
+            return []
+
+        session_dir = self.output_dir / self.session_id
+        if not session_dir.exists():
+            return []
+
+        return sorted(session_dir.glob("*.jpg")) + sorted(session_dir.glob("*.png"))
+
+
+def create_test_monitor_fixture(
+    output_dir: str | Path = None,
+    interval: float = 2.0,
+    auto_gif: bool = False,
+):
+    """
+    Create a pytest fixture for test monitoring.
+
+    Usage in conftest.py:
+        from scitex.browser.debugging import create_test_monitor_fixture
+
+        test_monitor = create_test_monitor_fixture(interval=2.0, auto_gif=True)
+
+    Args:
+        output_dir: Directory for screenshots
+        interval: Seconds between screenshots
+        auto_gif: Create GIF automatically on test completion
+
+    Returns:
+        A pytest fixture function
+    """
+    import pytest
+
+    @pytest.fixture
+    def test_monitor(request):
+        """Pytest fixture for visual test monitoring."""
+        monitor = TestMonitor(
+            output_dir=output_dir,
+            interval=interval,
+            verbose=True,
+            test_name=request.node.nodeid,
+        )
+        monitor.start()
+        yield monitor
+        monitor.stop()
+        if auto_gif:
+            gif_path = monitor.create_gif()
+            if gif_path:
+                print(f"[TestMonitor] GIF created: {gif_path}")
+
+    return test_monitor
+
+
+# Convenience function for quick monitoring
+def monitor_test(
+    test_func=None,
+    interval: float = 2.0,
+    auto_gif: bool = False,
+):
+    """
+    Decorator for monitoring tests with periodic screenshots.
+
+    Usage:
+        @monitor_test(interval=1.0, auto_gif=True)
+        def test_my_feature(page):
+            # test code...
+
+    Args:
+        test_func: Test function (for use without parentheses)
+        interval: Seconds between screenshots
+        auto_gif: Create GIF on completion
+    """
+    def decorator(func):
+        def wrapper(*args, **kwargs):
+            monitor = TestMonitor(
+                interval=interval,
+                verbose=True,
+                test_name=func.__name__,
+            )
+            monitor.start()
+            try:
+                return func(*args, **kwargs)
+            finally:
+                monitor.stop()
+                if auto_gif:
+                    monitor.create_gif()
+        return wrapper
+
+    if test_func is not None:
+        return decorator(test_func)
+    return decorator
+
+
+# EOF