crackerjack 0.31.9__py3-none-any.whl → 0.31.12__py3-none-any.whl

crackerjack/managers/test_executor.py

@@ -1,9 +1,3 @@
-"""Test execution engine with progress tracking and output parsing.
-
-This module handles the actual test execution, subprocess management, and real-time
-output parsing. Split from test_manager.py for better separation of concerns.
-"""
-
 import re
 import subprocess
 import threading
@@ -18,8 +12,6 @@ from .test_progress import TestProgress
 
 
 class TestExecutor:
-    """Handles test execution with real-time progress tracking."""
-
     def __init__(self, console: Console, pkg_path: Path) -> None:
         self.console = console
         self.pkg_path = pkg_path
@@ -29,7 +21,6 @@ class TestExecutor:
         cmd: list[str],
         timeout: int = 600,
     ) -> subprocess.CompletedProcess[str]:
-        """Execute test command with live progress display."""
         return self._execute_with_live_progress(cmd, timeout)
 
     def execute_with_ai_progress(
@@ -38,13 +29,11 @@ class TestExecutor:
         progress_callback: t.Callable[[dict[str, t.Any]], None],
         timeout: int = 600,
     ) -> subprocess.CompletedProcess[str]:
-        """Execute test command with AI-compatible progress callbacks."""
         return self._run_test_command_with_ai_progress(cmd, progress_callback, timeout)
 
     def _execute_with_live_progress(
         self, cmd: list[str], timeout: int
     ) -> subprocess.CompletedProcess[str]:
-        """Execute tests with Rich live progress display."""
         progress = self._initialize_progress()
 
         with Live(progress.format_progress(), console=self.console) as live:
@@ -61,12 +50,10 @@ class TestExecutor:
                 env=env,
             )
 
-            # Start reader threads
             stdout_thread, stderr_thread, monitor_thread = self._start_reader_threads(
                 process, progress, live
             )
 
-            # Wait for completion
             try:
                 process.wait(timeout=timeout)
             except subprocess.TimeoutExpired:
@@ -74,10 +61,8 @@ class TestExecutor:
                     process, progress, "Test execution timed out"
                 )
 
-            # Cleanup
             self._cleanup_threads([stdout_thread, stderr_thread, monitor_thread])
 
-            # Return completed process with string output
             stdout_str = process.stdout.read() if process.stdout else ""
             stderr_str = process.stderr.read() if process.stderr else ""
             return subprocess.CompletedProcess(
@@ -90,7 +75,6 @@ class TestExecutor:
         progress_callback: t.Callable[[dict[str, t.Any]], None],
         timeout: int = 600,
     ) -> subprocess.CompletedProcess[str]:
-        """Execute test command with AI progress callbacks."""
         progress = self._initialize_progress()
         env = self._setup_coverage_env()
 
@@ -101,13 +85,11 @@ class TestExecutor:
         return result
 
     def _initialize_progress(self) -> TestProgress:
-        """Initialize progress tracker."""
         progress = TestProgress()
         progress.start_time = time.time()
         return progress
 
     def _setup_test_environment(self) -> dict[str, str]:
-        """Set up environment variables for test execution."""
         import os
 
         cache_dir = Path.home() / ".cache" / "crackerjack" / "coverage"
@@ -119,7 +101,6 @@ class TestExecutor:
         return env
 
     def _setup_coverage_env(self) -> dict[str, str]:
-        """Set up coverage environment for AI mode."""
         import os
         from pathlib import Path
 
@@ -133,7 +114,6 @@ class TestExecutor:
     def _start_reader_threads(
         self, process: subprocess.Popen[str], progress: TestProgress, live: Live
     ) -> tuple[threading.Thread, threading.Thread, threading.Thread]:
-        """Start threads for reading stdout, stderr, and monitoring."""
         stdout_thread = self._create_stdout_reader(process, progress, live)
         stderr_thread = self._create_stderr_reader(process, progress, live)
         monitor_thread = self._create_monitor_thread(progress)
@@ -147,8 +127,6 @@ class TestExecutor:
     def _create_stdout_reader(
         self, process: subprocess.Popen[str], progress: TestProgress, live: Live
     ) -> threading.Thread:
-        """Create thread for reading stdout."""
-
         def read_output() -> None:
             if process.stdout:
                 for line in iter(process.stdout.readline, ""):
@@ -163,8 +141,6 @@ class TestExecutor:
     def _create_stderr_reader(
         self, process: subprocess.Popen[str], progress: TestProgress, live: Live
     ) -> threading.Thread:
-        """Create thread for reading stderr."""
-
         def read_stderr() -> None:
             if process.stderr:
                 for line in iter(process.stderr.readline, ""):
@@ -175,8 +151,6 @@ class TestExecutor:
         return threading.Thread(target=read_stderr, daemon=True)
 
     def _create_monitor_thread(self, progress: TestProgress) -> threading.Thread:
-        """Create thread for monitoring stuck tests."""
-
         def monitor_stuck_tests() -> None:
             last_update = time.time()
             last_test = ""
@@ -198,31 +172,26 @@ class TestExecutor:
         return threading.Thread(target=monitor_stuck_tests, daemon=True)
 
     def _process_test_output_line(self, line: str, progress: TestProgress) -> None:
-        """Process a single line of test output."""
         self._parse_test_line(line, progress)
 
     def _parse_test_line(self, line: str, progress: TestProgress) -> None:
-        """Parse test output line and update progress."""
-        # Handle collection completion
         if self._handle_collection_completion(line, progress):
             return
 
-        # Handle session events
         if self._handle_session_events(line, progress):
             return
 
-        # Handle collection progress
         if self._handle_collection_progress(line, progress):
             return
 
-        # Handle test execution
         if self._handle_test_execution(line, progress):
             return
 
     def _handle_collection_completion(self, line: str, progress: TestProgress) -> bool:
-        """Handle test collection completion."""
         if "collected" in line and ("item" in line or "test" in line):
-            match = re.search(r"(\d+) (?:item|test)", line)
+            match = re.search(
+                r"(\d +) (?: item | test)", line
+            )  # REGEX OK: parsing pytest output format
             if match:
                 progress.update(
                     total_tests=int(match.group(1)),
@@ -233,7 +202,6 @@ class TestExecutor:
         return False
 
     def _handle_session_events(self, line: str, progress: TestProgress) -> bool:
-        """Handle pytest session events."""
         if "session starts" in line and progress.collection_status != "Session started":
             progress.update(collection_status="Session started")
             return True
@@ -246,9 +214,7 @@ class TestExecutor:
         return False
 
     def _handle_collection_progress(self, line: str, progress: TestProgress) -> bool:
-        """Handle collection progress updates."""
         if progress.is_collecting:
-            # Look for file discovery patterns
             if line.endswith(".py") and ("test_" in line or "_test.py" in line):
                 with progress._lock:
                     if line not in progress._seen_files:
@@ -261,8 +227,6 @@ class TestExecutor:
         return False
 
     def _handle_test_execution(self, line: str, progress: TestProgress) -> bool:
-        """Handle test execution progress."""
-        # Test result patterns
         if " PASSED " in line:
             progress.update(passed=progress.passed + 1)
             self._extract_current_test(line, progress)
@@ -279,39 +243,32 @@ class TestExecutor:
             progress.update(errors=progress.errors + 1)
             self._extract_current_test(line, progress)
             return True
-        elif "::" in line and any(x in line for x in ("RUNNING", "test_")):
+        elif ":: " in line and any(x in line for x in ("RUNNING", "test_")):
             self._handle_running_test(line, progress)
             return True
 
         return False
 
     def _handle_running_test(self, line: str, progress: TestProgress) -> None:
-        """Handle currently running test indicator."""
-        if "::" in line:
-            # Extract test name from line
-            test_parts = line.split("::")
+        if ":: " in line:
+            test_parts = line.split(":: ")
             if len(test_parts) >= 2:
-                test_name = "::".join(test_parts[-2:])
+                test_name = ":: ".join(test_parts[-2:])
                 progress.update(current_test=test_name)
 
     def _extract_current_test(self, line: str, progress: TestProgress) -> None:
-        """Extract current test name from output line."""
-        if "::" in line:
-            # Extract test identifier
+        if ":: " in line:
             parts = line.split(" ")
             for part in parts:
-                if "::" in part:
+                if ":: " in part:
                     progress.update(current_test=part)
                     break
 
     def _update_display_if_needed(self, progress: TestProgress, live: Live) -> None:
-        """Update display if enough time has passed or significant change occurred."""
         if self._should_refresh_display(progress):
             live.update(progress.format_progress())
 
     def _should_refresh_display(self, progress: TestProgress) -> bool:
-        """Determine if display should be refreshed."""
-        # Only refresh on significant changes to reduce spam
         return (
             progress.is_complete
             or progress.total_tests > 0
@@ -319,12 +276,10 @@ class TestExecutor:
         )
 
     def _mark_test_as_stuck(self, progress: TestProgress, test_name: str) -> None:
-        """Mark a test as potentially stuck."""
         if test_name:
             progress.update(current_test=f"🐌 {test_name} (slow)")
 
     def _cleanup_threads(self, threads: list[threading.Thread]) -> None:
-        """Clean up reader threads."""
         for thread in threads:
             if thread.is_alive():
                 thread.join(timeout=1.0)
@@ -332,7 +287,6 @@ class TestExecutor:
     def _handle_progress_error(
         self, process: subprocess.Popen[str], progress: TestProgress, error_msg: str
     ) -> None:
-        """Handle progress tracking errors."""
         process.terminate()
         progress.update(is_complete=True, current_test=f"❌ {error_msg}")
 
@@ -344,7 +298,6 @@ class TestExecutor:
         progress_callback: t.Callable[[dict[str, t.Any]], None],
         timeout: int,
     ) -> subprocess.CompletedProcess[str]:
-        """Execute test process with AI progress tracking."""
         process = subprocess.Popen(
             cmd,
             cwd=self.pkg_path,
@@ -371,7 +324,6 @@ class TestExecutor:
         progress: TestProgress,
         progress_callback: t.Callable[[dict[str, t.Any]], None],
     ) -> list[str]:
-        """Read stdout with progress updates."""
         stdout_lines = []
 
         if process.stdout:
@@ -388,7 +340,6 @@ class TestExecutor:
         return stdout_lines
 
     def _read_stderr_lines(self, process: subprocess.Popen[str]) -> list[str]:
-        """Read stderr lines."""
         stderr_lines = []
 
         if process.stderr:
@@ -404,7 +355,6 @@ class TestExecutor:
     def _wait_for_process_completion(
         self, process: subprocess.Popen[str], timeout: int
     ) -> int:
-        """Wait for process completion with timeout."""
         try:
             process.wait(timeout=timeout)
             return process.returncode
@@ -417,7 +367,6 @@ class TestExecutor:
         progress: TestProgress,
         progress_callback: t.Callable[[dict[str, t.Any]], None],
     ) -> None:
-        """Emit progress update for AI consumption."""
         progress_data = {
             "type": "test_progress",
             "total_tests": progress.total_tests,
@@ -439,5 +388,4 @@ class TestExecutor:
         from contextlib import suppress
 
         with suppress(Exception):
-            # Don't let progress callback errors affect test execution
             progress_callback(progress_data)

crackerjack/managers/test_manager.py

@@ -1,15 +1,3 @@
-"""Refactored test manager with focused responsibilities.
-
-This is the new modular test manager that delegates to specialized components:
-- TestExecutor: Handles test execution and progress tracking
-- TestCommandBuilder: Builds pytest commands with appropriate options
-- TestProgress: Tracks and displays test progress
-- CoverageRatchetService: Manages coverage requirements
-
-REFACTORING NOTE: Original test_manager.py was 1133 lines with 60+ methods.
-This refactored version is ~200 lines and delegates to focused modules.
-"""
-
 import subprocess
 import time
 import typing as t
@@ -25,18 +13,14 @@ from .test_executor import TestExecutor
 
 
 class TestManager:
-    """Refactored test manager with modular architecture."""
-
     def __init__(self, console: Console, pkg_path: Path) -> None:
         self.console = console
         self.pkg_path = pkg_path
 
-        # Initialize specialized components
         self.executor = TestExecutor(console, pkg_path)
         self.command_builder = TestCommandBuilder(pkg_path)
         self.coverage_ratchet = CoverageRatchetService(pkg_path, console)
 
-        # State
         self._last_test_failures: list[str] = []
         self._progress_callback: t.Callable[[dict[str, t.Any]], None] | None = None
         self.coverage_ratchet_enabled = True
@@ -45,21 +29,18 @@ class TestManager:
         self,
         callback: t.Callable[[dict[str, t.Any]], None] | None,
     ) -> None:
-        """Set callback for AI mode structured progress updates."""
         self._progress_callback = callback
 
     def set_coverage_ratchet_enabled(self, enabled: bool) -> None:
-        """Enable or disable the coverage ratchet system."""
         self.coverage_ratchet_enabled = enabled
         if enabled:
             self.console.print(
-                "[cyan]📊[/cyan] Coverage ratchet enabled - targeting 100% coverage"
+                "[cyan]📊[/ cyan] Coverage ratchet enabled-targeting 100 % coverage"
             )
         else:
-            self.console.print("[yellow]⚠️[/yellow] Coverage ratchet disabled")
+            self.console.print("[yellow]⚠️[/ yellow] Coverage ratchet disabled")
 
     def run_tests(self, options: OptionsProtocol) -> bool:
-        """Run tests with comprehensive progress tracking and coverage analysis."""
         start_time = time.time()
 
         try:
@@ -77,44 +58,39 @@ class TestManager:
             return self._handle_test_error(start_time, e)
 
     def run_specific_tests(self, test_pattern: str) -> bool:
-        """Run tests matching a specific pattern."""
-        self.console.print(f"[cyan]🧪[/cyan] Running tests matching: {test_pattern}")
+        self.console.print(f"[cyan]🧪[/ cyan] Running tests matching: {test_pattern}")
 
         cmd = self.command_builder.build_specific_test_command(test_pattern)
         result = self.executor.execute_with_progress(cmd)
 
         success = result.returncode == 0
         if success:
-            self.console.print("[green]✅[/green] Specific tests passed")
+            self.console.print("[green]✅[/ green] Specific tests passed")
         else:
-            self.console.print("[red]❌[/red] Some specific tests failed")
+            self.console.print("[red]❌[/ red] Some specific tests failed")
 
         return success
 
     def validate_test_environment(self) -> bool:
-        """Validate test environment and configuration."""
         if not self.has_tests():
-            self.console.print("[yellow]⚠️[/yellow] No tests found")
+            self.console.print("[yellow]⚠️[/ yellow] No tests found")
             return False
 
-        # Test basic pytest collection
         cmd = self.command_builder.build_validation_command()
         result = subprocess.run(cmd, cwd=self.pkg_path, capture_output=True, text=True)
 
         if result.returncode != 0:
-            self.console.print("[red]❌[/red] Test environment validation failed")
+            self.console.print("[red]❌[/ red] Test environment validation failed")
             self.console.print(result.stderr)
             return False
 
-        self.console.print("[green]✅[/green] Test environment validated")
+        self.console.print("[green]✅[/ green] Test environment validated")
         return True
 
     def get_coverage_ratchet_status(self) -> dict[str, t.Any]:
-        """Get comprehensive coverage ratchet status."""
         return self.coverage_ratchet.get_status_report()
 
     def get_test_stats(self) -> dict[str, t.Any]:
-        """Get comprehensive test execution statistics."""
         return {
             "has_tests": self.has_tests(),
             "coverage_ratchet_enabled": self.coverage_ratchet_enabled,
@@ -122,22 +98,46 @@ class TestManager:
         }
 
     def get_test_failures(self) -> list[str]:
-        """Get list of recent test failures."""
         return self._last_test_failures.copy()
 
     def get_test_command(self, options: OptionsProtocol) -> list[str]:
-        """Get the test command that would be executed."""
         return self.command_builder.build_command(options)
 
     def get_coverage_report(self) -> str | None:
-        """Get coverage report if available."""
         try:
             return self.coverage_ratchet.get_coverage_report()
         except Exception:
             return None
 
+    def get_coverage(self) -> dict[str, t.Any]:
+        try:
+            status = self.coverage_ratchet.get_status_report()
+
+            if status.get("status") == "not_initialized":
+                return {
+                    "status": "not_initialized",
+                    "coverage_percent": 0.0,
+                    "message": "Coverage ratchet not initialized",
+                }
+
+            return {
+                "status": "active",
+                "coverage_percent": status.get("current_coverage", 0.0),
+                "target_coverage": status.get("target_coverage", 100.0),
+                "next_milestone": status.get("next_milestone"),
+                "progress_percent": status.get("progress_percent", 0.0),
+                "last_updated": status.get("last_updated"),
+                "milestones_achieved": status.get("milestones_achieved", []),
+            }
+        except Exception as e:
+            return {
+                "status": "error",
+                "coverage_percent": 0.0,
+                "error": str(e),
+                "message": "Failed to get coverage information",
+            }
+
     def has_tests(self) -> bool:
-        """Check if project has tests."""
         test_directories = ["tests", "test"]
         test_files = ["test_*.py", "*_test.py"]
 
@@ -148,19 +148,15 @@ class TestManager:
                     if list(test_path.glob(f"**/{test_file_pattern}")):
                         return True
 
-        # Check for test files in root directory
         for test_file_pattern in test_files:
             if list(self.pkg_path.glob(test_file_pattern)):
                 return True
 
         return False
 
-    # Private implementation methods
-
     def _execute_test_workflow(
         self, options: OptionsProtocol
     ) -> subprocess.CompletedProcess[str]:
-        """Execute the complete test workflow."""
         self._print_test_start_message(options)
 
         cmd = self.command_builder.build_command(options)
@@ -172,17 +168,15 @@ class TestManager:
         return self.executor.execute_with_progress(cmd, self._get_timeout(options))
 
     def _print_test_start_message(self, options: OptionsProtocol) -> None:
-        """Print test execution start message."""
         workers = self.command_builder.get_optimal_workers(options)
         timeout = self.command_builder.get_test_timeout(options)
 
         self.console.print(
-            f"[cyan]🧪[/cyan] Running tests (workers: {workers}, timeout: {timeout}s)"
+            f"[cyan]🧪[/ cyan] Running tests (workers: {workers}, timeout: {timeout}s)"
         )
 
     def _handle_test_success(self, output: str, duration: float) -> bool:
-        """Handle successful test execution."""
-        self.console.print(f"[green]✅[/green] Tests passed in {duration:.1f}s")
+        self.console.print(f"[green]✅[/ green] Tests passed in {duration: .1f}s")
 
         if self.coverage_ratchet_enabled:
             return self._process_coverage_ratchet()
@@ -190,22 +184,19 @@ class TestManager:
         return True
 
     def _handle_test_failure(self, output: str, duration: float) -> bool:
-        """Handle failed test execution."""
-        self.console.print(f"[red]❌[/red] Tests failed in {duration:.1f}s")
+        self.console.print(f"[red]❌[/ red] Tests failed in {duration: .1f}s")
 
         self._last_test_failures = self._extract_failure_lines(output)
         return False
 
     def _handle_test_error(self, start_time: float, error: Exception) -> bool:
-        """Handle test execution errors."""
         duration = time.time() - start_time
         self.console.print(
-            f"[red]💥[/red] Test execution error after {duration:.1f}s: {error}"
+            f"[red]💥[/ red] Test execution error after {duration: .1f}s: {error}"
         )
         return False
 
     def _process_coverage_ratchet(self) -> bool:
-        """Process coverage ratchet checks."""
         if not self.coverage_ratchet_enabled:
             return True
 
@@ -213,31 +204,32 @@ class TestManager:
         return self._handle_ratchet_result(ratchet_result)
 
     def _handle_ratchet_result(self, ratchet_result: dict[str, t.Any]) -> bool:
-        """Handle coverage ratchet results."""
         if ratchet_result.get("success", False):
             if ratchet_result.get("improved", False):
                 self._handle_coverage_improvement(ratchet_result)
             return True
         else:
-            self.console.print(
-                f"[red]📉[/red] Coverage regression: "
-                f"{ratchet_result.get('current_coverage', 0):.2f}% < "
-                f"{ratchet_result.get('previous_coverage', 0):.2f}%"
-            )
+            if "message" in ratchet_result:
+                self.console.print(f"[red]📉[/ red] {ratchet_result['message']}")
+            else:
+                current = ratchet_result.get("current_coverage", 0)
+                previous = ratchet_result.get("previous_coverage", 0)
+                self.console.print(
+                    f"[red]📉[/ red] Coverage regression: "
+                    f"{current:.2f}% < {previous:.2f}%"
+                )
             return False
 
     def _handle_coverage_improvement(self, ratchet_result: dict[str, t.Any]) -> None:
-        """Handle coverage improvements."""
         improvement = ratchet_result.get("improvement", 0)
         current = ratchet_result.get("current_coverage", 0)
 
         self.console.print(
-            f"[green]📈[/green] Coverage improved by {improvement:.2f}% "
-            f"to {current:.2f}%"
+            f"[green]📈[/ green] Coverage improved by {improvement: .2f}% "
+            f"to {current: .2f}%"
         )
 
     def _extract_failure_lines(self, output: str) -> list[str]:
-        """Extract failure information from test output."""
         failures = []
         lines = output.split("\n")
 
@@ -247,12 +239,10 @@ class TestManager:
             ):
                 failures.append(line.strip())
 
-        return failures[:10]  # Limit to first 10 failures
+        return failures[:10]
 
     def _get_timeout(self, options: OptionsProtocol) -> int:
-        """Get timeout for test execution."""
         return self.command_builder.get_test_timeout(options)
 
 
-# For backward compatibility, also export the old class name
 TestManagementImpl = TestManager