lintro 0.13.2__py3-none-any.whl → 0.17.2__py3-none-any.whl

lintro/tools/implementations/pytest/pytest_command_builder.py

@@ -0,0 +1,311 @@
+"""Command building functions for pytest tool.
+
+This module contains command building logic extracted from PytestTool to improve
+maintainability and reduce file size. Functions are organized by command section.
+"""
+
+import os
+
+from loguru import logger
+
+from lintro.tools.implementations.pytest.pytest_utils import (
+    check_plugin_installed,
+    get_parallel_workers_from_preset,
+)
+
+# Constants for pytest configuration
+PYTEST_TEST_MODE_ENV: str = "LINTRO_TEST_MODE"
+PYTEST_TEST_MODE_VALUE: str = "1"
+
+
+def build_base_command(tool) -> list[str]:
+    """Build the base pytest command.
+
+    Args:
+        tool: PytestTool instance.
+
+    Returns:
+        list[str]: Base command list starting with pytest executable.
+    """
+    return tool._get_executable_command(tool_name="pytest")
+
+
+def add_verbosity_options(cmd: list[str], options: dict) -> None:
+    """Add verbosity and traceback options to command.
+
+    Args:
+        cmd: Command list to modify.
+        options: Options dictionary.
+    """
+    # Add verbosity - ensure it's enabled if show_progress is True
+    show_progress = options.get("show_progress", True)
+    verbose = options.get("verbose", show_progress)  # Default to show_progress value
+    if verbose or show_progress:
+        cmd.append("-v")
+
+    # Add traceback format
+    tb_format = options.get("tb", "short")
+    cmd.extend(["--tb", tb_format])
+
+    # Add maxfail only if specified
+    # Note: We default to None to avoid stopping early and run all tests
+    maxfail = options.get("maxfail")
+    if maxfail is not None:
+        cmd.extend(["--maxfail", str(maxfail)])
+
+    # Add no-header
+    if options.get("no_header", True):
+        cmd.append("--no-header")
+
+    # Add disable-warnings
+    if options.get("disable_warnings", True):
+        cmd.append("--disable-warnings")
+
+
+def add_output_options(cmd: list[str], options: dict) -> str | None:
+    """Add output format options (JSON, JUnit XML, HTML) to command.
+
+    Args:
+        cmd: Command list to modify.
+        options: Options dictionary.
+
+    Returns:
+        str | None: The junitxml path if auto-enabled, None otherwise.
+    """
+    # Add output format options
+    if options.get("json_report", False):
+        cmd.append("--json-report")
+        cmd.append("--json-report-file=pytest-report.json")
+
+    # Track if junitxml was explicitly provided
+    junitxml_explicit = "junitxml" in options
+    junitxml_value = options.get("junitxml")
+    auto_junitxml_path: str | None = None
+
+    if junitxml_value:
+        # User provided a truthy value, use it
+        cmd.extend(["--junitxml", junitxml_value])
+    else:
+        # Auto-enable junitxml to capture all test results including skipped tests
+        # Only if user didn't explicitly disable it
+        # (junitxml_explicit True but falsy value)
+        auto_junitxml = options.get("auto_junitxml", True)
+        if not junitxml_explicit and auto_junitxml:
+            cmd.extend(["--junitxml", "report.xml"])
+            auto_junitxml_path = "report.xml"
+            logger.debug("Auto-enabled junitxml=report.xml to capture skipped tests")
+
+    # Add pytest-html HTML report if specified
+    html_report = options.get("html_report")
+    if html_report:
+        cmd.extend(["--html", html_report])
+        logger.debug(f"HTML report enabled: {html_report}")
+
+    return auto_junitxml_path
+
+
+def add_parallel_options(cmd: list[str], options: dict) -> None:
+    """Add parallel execution options to command.
+
+    Args:
+        cmd: Command list to modify.
+        options: Options dictionary.
+    """
+    # Add pytest-xdist parallel execution
+    # Priority: parallel_preset > workers
+    workers = options.get("workers")
+    parallel_preset = options.get("parallel_preset")
+    if parallel_preset:
+        # Convert preset to worker count
+        workers = get_parallel_workers_from_preset(parallel_preset)
+        logger.debug(
+            f"Using parallel preset '{parallel_preset}' -> workers={workers}",
+        )
+    if workers:
+        cmd.extend(["-n", str(workers)])
+
+
+def add_coverage_options(cmd: list[str], options: dict) -> None:
+    """Add coverage options to command.
+
+    Args:
+        cmd: Command list to modify.
+        options: Options dictionary.
+    """
+    # Add coverage threshold if specified
+    coverage_threshold = options.get("coverage_threshold")
+    if coverage_threshold is not None:
+        cmd.extend(["--cov-fail-under", str(coverage_threshold)])
+
+    # Add coverage report options (requires pytest-cov)
+    coverage_html = options.get("coverage_html")
+    coverage_xml = options.get("coverage_xml")
+    coverage_report = options.get("coverage_report", False)
+
+    # If coverage_report is True, generate both HTML and XML
+    if coverage_report:
+        if not coverage_html:
+            coverage_html = "htmlcov"
+        if not coverage_xml:
+            coverage_xml = "coverage.xml"
+
+    # Add coverage collection if any coverage options are specified
+    if coverage_html or coverage_xml or coverage_threshold is not None:
+        # Add --cov flag to enable coverage collection
+        # Default to current directory, but can be overridden
+        cmd.append("--cov=.")
+
+    # Add coverage HTML report
+    if coverage_html:
+        # pytest-cov uses --cov-report=html or --cov-report=html:dir
+        # Only use default --cov-report=html for exact "htmlcov" match
+        # Custom paths ending in "htmlcov" should use the custom directory format
+        if coverage_html == "htmlcov":
+            cmd.append("--cov-report=html")
+        else:
+            # Custom directory (remove trailing /index.html if present)
+            html_dir = coverage_html.replace(
+                "/index.html",
+                "",
+            ).replace("index.html", "")
+            if html_dir:
+                cmd.extend(["--cov-report", f"html:{html_dir}"])
+            else:
+                cmd.append("--cov-report=html")
+        logger.debug(f"Coverage HTML report enabled: {coverage_html}")
+
+    # Add coverage XML report
+    if coverage_xml:
+        # pytest-cov uses --cov-report=xml or --cov-report=xml:file
+        # (without .xml extension)
+        if coverage_xml == "coverage.xml":
+            cmd.append("--cov-report=xml")
+        else:
+            # Custom file path (remove .xml extension for the flag)
+            xml_file = (
+                coverage_xml.replace(".xml", "")
+                if coverage_xml.endswith(".xml")
+                else coverage_xml
+            )
+            if xml_file:
+                cmd.extend(["--cov-report", f"xml:{xml_file}"])
+            else:
+                cmd.append("--cov-report=xml")
+        logger.debug(f"Coverage XML report enabled: {coverage_xml}")
+
+
+def add_test_mode_options(cmd: list[str]) -> None:
+    """Add test mode isolation options to command.
+
+    Args:
+        cmd: Command list to modify.
+    """
+    # Add test mode isolation if in test mode
+    if os.environ.get(PYTEST_TEST_MODE_ENV) == PYTEST_TEST_MODE_VALUE:
+        cmd.append("--strict-markers")
+        cmd.append("--strict-config")
+
+
+def add_plugin_options(cmd: list[str], options: dict) -> None:
+    """Add plugin-specific options to command.
+
+    Args:
+        cmd: Command list to modify.
+        options: Options dictionary.
+    """
+    # Add pytest-timeout options if timeout is specified
+    # Only add timeout arguments if pytest-timeout plugin is installed
+    timeout = options.get("timeout")
+    if timeout is not None:
+        if check_plugin_installed("pytest-timeout"):
+            cmd.extend(["--timeout", str(timeout)])
+            # Default timeout method to 'signal' if not specified
+            timeout_method = options.get("timeout_method", "signal")
+            cmd.extend(["--timeout-method", timeout_method])
+            logger.debug(f"Timeout enabled: {timeout}s (method: {timeout_method})")
+        else:
+            logger.warning(
+                "pytest-timeout plugin not installed; timeout option ignored. "
+                "Install with: pip install pytest-timeout",
+            )
+
+    # Add pytest-rerunfailures options
+    reruns = options.get("reruns")
+    if reruns is not None and reruns > 0:
+        cmd.extend(["--reruns", str(reruns)])
+
+        reruns_delay = options.get("reruns_delay")
+        if reruns_delay is not None and reruns_delay > 0:
+            cmd.extend(["--reruns-delay", str(reruns_delay)])
+            logger.debug(f"Reruns enabled: {reruns} times with {reruns_delay}s delay")
+        else:
+            logger.debug(f"Reruns enabled: {reruns} times")
+
+
+def add_ignore_options(cmd: list[str], tool) -> None:
+    """Add ignore options to command for exclude patterns.
+
+    Args:
+        cmd: Command list to modify.
+        tool: PytestTool instance.
+    """
+    # Add --ignore flags for each exclude pattern
+    for pattern in tool.exclude_patterns:
+        # pytest --ignore expects directory paths, not glob patterns
+        # Convert glob patterns to directory paths where possible
+        if pattern.endswith("/*"):
+            # Remove /* from the end to get directory path
+            ignore_path = pattern[:-2]
+            cmd.extend(["--ignore", ignore_path])
+        elif pattern.endswith("/"):
+            # Pattern already ends with /, remove it
+            ignore_path = pattern[:-1]
+            cmd.extend(["--ignore", ignore_path])
+        else:
+            # For other patterns, try to use them as-is
+            # pytest --ignore works with directory names
+            cmd.extend(["--ignore", pattern])
+
+
+def build_check_command(
+    tool,
+    files: list[str],
+    fix: bool = False,
+) -> tuple[list[str], str | None]:
+    """Build the pytest command.
+
+    Args:
+        tool: PytestTool instance.
+        files: list[str]: List of files to test.
+        fix: bool: Ignored for pytest (not applicable).
+
+    Returns:
+        tuple[list[str], str | None]: Tuple of (command arguments, auto junitxml path).
+    """
+    cmd = build_base_command(tool)
+
+    # Add verbosity options
+    add_verbosity_options(cmd, tool.options)
+
+    # Add output options and capture auto-enabled junitxml path
+    auto_junitxml_path = add_output_options(cmd, tool.options)
+
+    # Add parallel options
+    add_parallel_options(cmd, tool.options)
+
+    # Add coverage options
+    add_coverage_options(cmd, tool.options)
+
+    # Add plugin options (timeout, reruns, etc.)
+    add_plugin_options(cmd, tool.options)
+
+    # Add test mode options
+    add_test_mode_options(cmd)
+
+    # Add ignore options for exclude patterns
+    add_ignore_options(cmd, tool)
+
+    # Add files
+    cmd.extend(files)
+
+    return cmd, auto_junitxml_path

lintro/tools/implementations/pytest/pytest_config.py

@@ -0,0 +1,200 @@
+"""Pytest configuration management.
+
+This module contains the PytestConfiguration dataclass that encapsulates
+all pytest-specific option management and validation logic.
+"""
+
+from dataclasses import dataclass
+from typing import Any
+
+from lintro.tools.implementations.pytest.pytest_option_validators import (
+    validate_pytest_options,
+)
+
+
+@dataclass
+class PytestConfiguration:
+    """Configuration class for pytest-specific options.
+
+    This dataclass encapsulates all pytest configuration options and provides
+    validation and management methods. It follows the project's preference for
+    dataclasses and proper data modeling.
+
+    Attributes:
+        verbose: Enable verbose output.
+        tb: Traceback format (short, long, auto, line, native).
+        maxfail: Stop after first N failures.
+        no_header: Disable header.
+        disable_warnings: Disable warnings.
+        json_report: Enable JSON report output.
+        junitxml: Path for JUnit XML output.
+        run_docker_tests: Enable Docker tests (default: False).
+        slow_test_threshold: Duration threshold in seconds for slow test warning
+            (default: 1.0).
+        total_time_warning: Total execution time threshold in seconds for warning
+            (default: 60.0).
+        workers: Number of parallel workers for pytest-xdist (auto, N, or None).
+        coverage_threshold: Minimum coverage percentage to require (0-100).
+        auto_junitxml: Auto-enable junitxml in CI environments (default: True).
+        detect_flaky: Enable flaky test detection (default: True).
+        flaky_min_runs: Minimum runs before detecting flaky tests (default: 3).
+        flaky_failure_rate: Minimum failure rate to consider flaky (default: 0.3).
+        html_report: Path for HTML report output (pytest-html plugin).
+        parallel_preset: Parallel execution preset (auto, small, medium, large).
+        list_plugins: List all installed pytest plugins.
+        check_plugins: Check if required plugins are installed.
+        required_plugins: Comma-separated list of required plugin names.
+        coverage_html: Path for HTML coverage report (requires pytest-cov).
+        coverage_xml: Path for XML coverage report (requires pytest-cov).
+        coverage_report: Generate both HTML and XML coverage reports.
+        collect_only: List tests without executing them.
+        list_fixtures: List all available fixtures.
+        fixture_info: Show detailed information about a specific fixture.
+        list_markers: List all available markers.
+        parametrize_help: Show help for parametrized tests.
+        show_progress: Show progress during test execution (default: True).
+        timeout: Timeout in seconds for individual tests (pytest-timeout plugin).
+        reruns: Number of times to retry failed tests (pytest-rerunfailures plugin).
+        reruns_delay: Delay in seconds between retries (pytest-rerunfailures plugin).
+    """
+
+    verbose: bool | None = None
+    tb: str | None = None
+    maxfail: int | None = None
+    no_header: bool | None = None
+    disable_warnings: bool | None = None
+    json_report: bool | None = None
+    junitxml: str | None = None
+    run_docker_tests: bool | None = None
+    slow_test_threshold: float | None = None
+    total_time_warning: float | None = None
+    workers: str | None = None
+    coverage_threshold: float | None = None
+    auto_junitxml: bool | None = None
+    detect_flaky: bool | None = None
+    flaky_min_runs: int | None = None
+    flaky_failure_rate: float | None = None
+    html_report: str | None = None
+    parallel_preset: str | None = None
+    list_plugins: bool | None = None
+    check_plugins: bool | None = None
+    required_plugins: str | None = None
+    coverage_html: str | None = None
+    coverage_xml: str | None = None
+    coverage_report: bool | None = None
+    collect_only: bool | None = None
+    list_fixtures: bool | None = None
+    fixture_info: str | None = None
+    list_markers: bool | None = None
+    parametrize_help: bool | None = None
+    show_progress: bool | None = None
+    timeout: int | None = None
+    reruns: int | None = None
+    reruns_delay: int | None = None
+
+    def set_options(self, **kwargs: Any) -> None:
+        """Set pytest-specific options with validation.
+
+        Args:
+            **kwargs: Option key-value pairs to set.
+        """
+        # Extract only the options that belong to this configuration
+        config_fields = {field.name for field in self.__dataclass_fields__.values()}
+
+        # Validate all options using extracted validator
+        validate_pytest_options(
+            **{k: v for k, v in kwargs.items() if k in config_fields},
+        )
+
+        # Set default junitxml if auto_junitxml is enabled and junitxml not
+        # explicitly set
+        junitxml = kwargs.get("junitxml")
+        auto_junitxml = kwargs.get("auto_junitxml")
+        if junitxml is None and (auto_junitxml is None or auto_junitxml):
+            junitxml = "report.xml"
+            kwargs = kwargs.copy()
+            kwargs["junitxml"] = junitxml
+
+        # Update the dataclass fields
+        for key, value in kwargs.items():
+            if key in config_fields:
+                setattr(self, key, value)
+
+    def get_options_dict(self) -> dict[str, Any]:
+        """Get a dictionary of all non-None options.
+
+        Returns:
+            Dict[str, Any]: Dictionary of option key-value pairs, excluding None values.
+        """
+        options = {}
+        for field_name, _field_info in self.__dataclass_fields__.items():
+            value = getattr(self, field_name)
+            if value is not None:
+                options[field_name] = value
+        return options
+
+    def is_special_mode(self) -> bool:
+        """Check if any special mode is enabled.
+
+        Special modes are modes that don't run tests but perform other operations
+        like listing plugins, fixtures, etc.
+
+        Returns:
+            bool: True if any special mode is enabled.
+        """
+        special_modes = [
+            "list_plugins",
+            "check_plugins",
+            "collect_only",
+            "list_fixtures",
+            "list_markers",
+            "parametrize_help",
+        ]
+
+        # Check boolean special modes
+        if any(getattr(self, mode, False) for mode in special_modes):
+            return True
+
+        # Check fixture_info (string value, not boolean)
+        return bool(getattr(self, "fixture_info", None))
+
+    def get_special_mode(self) -> str | None:
+        """Get the active special mode, if any.
+
+        Returns:
+            str | None: Name of the active special mode, or None if no special mode.
+        """
+        special_modes = [
+            ("list_plugins", "list_plugins"),
+            ("check_plugins", "check_plugins"),
+            ("collect_only", "collect_only"),
+            ("list_fixtures", "list_fixtures"),
+            ("list_markers", "list_markers"),
+            ("parametrize_help", "parametrize_help"),
+        ]
+
+        for attr_name, mode_name in special_modes:
+            if getattr(self, attr_name, False):
+                return mode_name
+
+        # Check for fixture_info (string value, not boolean)
+        if getattr(self, "fixture_info", None):
+            return "fixture_info"
+
+        return None
+
+    def get_special_mode_value(self, mode: str) -> Any:
+        """Get the value for a special mode.
+
+        Args:
+            mode: The special mode name.
+
+        Returns:
+            Any: The value associated with the special mode.
+        """
+        if mode == "fixture_info":
+            return self.fixture_info
+        elif mode == "check_plugins":
+            return self.required_plugins
+        else:
+            return getattr(self, mode, False)

lintro/tools/implementations/pytest/pytest_error_handler.py

@@ -0,0 +1,128 @@
+"""Pytest error handling.
+
+This module contains the PytestErrorHandler class that handles various error
+scenarios consistently and provides standardized error messages.
+"""
+
+import subprocess  # nosec B404 - used safely with shell disabled
+from dataclasses import dataclass
+
+from loguru import logger
+
+from lintro.models.core.tool_result import ToolResult
+
+
+@dataclass
+class PytestErrorHandler:
+    """Handles pytest error scenarios consistently.
+
+    This class encapsulates error handling logic for various pytest execution
+    failures, providing standardized error messages and ToolResult objects.
+
+    Attributes:
+        tool_name: Name of the tool (e.g., "pytest").
+    """
+
+    tool_name: str = "pytest"
+
+    def handle_timeout_error(
+        self,
+        timeout_val: int,
+        cmd: list[str],
+        initial_count: int = 0,
+    ) -> ToolResult:
+        """Handle timeout errors consistently.
+
+        Args:
+            timeout_val: The timeout value that was exceeded.
+            cmd: Command that timed out.
+            initial_count: Number of issues discovered before timeout.
+
+        Returns:
+            ToolResult: Standardized timeout error result.
+        """
+        # Format the command for display
+        cmd_str = " ".join(cmd[:4]) if len(cmd) >= 4 else " ".join(cmd)
+        if len(cmd) > 4:
+            cmd_str += f" ... ({len(cmd) - 4} more args)"
+
+        error_msg = (
+            f"❌ pytest execution timed out after {timeout_val}s\n\n"
+            f"Command: {cmd_str}\n\n"
+            "Possible causes:\n"
+            "  • Tests are taking too long to run\n"
+            "  • Some tests are hanging or blocked (e.g., waiting for I/O)\n"
+            "  • Test discovery is slow or stuck\n"
+            "  • Resource exhaustion (memory, file descriptors)\n\n"
+            "Solutions:\n"
+            "  1. Increase timeout: lintro test --tool-options timeout=600\n"
+            "  2. Run fewer tests: lintro test tests/unit/ (vs full test suite)\n"
+            "  3. Run in parallel: lintro test --tool-options workers=auto\n"
+            "  4. Skip slow tests: lintro test -m 'not slow'\n"
+            "  5. Debug directly: pytest -v --tb=short <test_file>\n"
+        )
+        logger.error(error_msg)
+        return ToolResult(
+            name=self.tool_name,
+            success=False,
+            issues=[],
+            output=error_msg,
+            issues_count=max(initial_count, 1),  # Count timeout as execution failure
+        )
+
+    def handle_execution_error(
+        self,
+        error: Exception,
+        cmd: list[str],
+    ) -> ToolResult:
+        """Handle execution errors consistently.
+
+        Args:
+            error: The exception that occurred.
+            cmd: Command that failed.
+
+        Returns:
+            ToolResult: Standardized error result.
+        """
+        if isinstance(error, FileNotFoundError):
+            error_msg = (
+                f"pytest executable not found: {error}\n\n"
+                "Please ensure pytest is installed:\n"
+                "  - Install via pip: pip install pytest\n"
+                "  - Install via uv: uv add pytest\n"
+                "  - Or install as dev dependency: uv add --dev pytest\n\n"
+                "After installation, verify pytest is available:\n"
+                "  pytest --version"
+            )
+        elif isinstance(error, subprocess.CalledProcessError):
+            error_msg = (
+                f"pytest execution failed with return code {error.returncode}\n\n"
+                "Common causes:\n"
+                "  - Syntax errors in test files\n"
+                "  - Missing dependencies or imports\n"
+                "  - Configuration issues in pytest.ini or pyproject.toml\n"
+                "  - Permission errors accessing test files\n\n"
+                "Try running pytest directly to see detailed error:\n"
+                f"  {' '.join(cmd[:3])} ..."
+            )
+        else:
+            # Generic error handling with helpful context
+            error_type = type(error).__name__
+            error_msg = (
+                f"Unexpected error running pytest: {error_type}: {error}\n\n"
+                "Please report this issue if it persists. "
+                "For troubleshooting:\n"
+                "  - Verify pytest is installed: pytest --version\n"
+                "  - Check test files for syntax errors\n"
+                "  - Review pytest configuration files\n"
+                "  - Run pytest directly to see full output"
+            )
+
+        logger.error(error_msg)
+        return ToolResult(
+            name=self.tool_name,
+            success=False,
+            issues=[],
+            output=error_msg,
+            issues_count=1 if isinstance(error, subprocess.TimeoutExpired) else 0,
+        )