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

lintro/tools/implementations/pytest/pytest_executor.py

@@ -0,0 +1,122 @@
+"""Pytest execution logic.
+
+This module contains the PytestExecutor class that handles test execution,
+environment management, and subprocess operations.
+"""
+
+import os
+from dataclasses import dataclass
+
+from loguru import logger
+
+from lintro.tools.implementations.pytest.pytest_config import PytestConfiguration
+from lintro.tools.implementations.pytest.pytest_utils import collect_tests_once
+
+
+@dataclass
+class PytestExecutor:
+    """Handles pytest test execution and environment management.
+
+    This class encapsulates the logic for executing pytest tests, managing
+    Docker test environment variables, and handling subprocess operations.
+
+    Attributes:
+        config: PytestConfiguration instance with test execution options.
+        tool: Reference to the parent tool for subprocess execution.
+    """
+
+    config: PytestConfiguration
+    tool: object  # Required: must be set by the parent tool
+
+    def prepare_test_execution(
+        self,
+        target_files: list[str],
+    ) -> tuple[int, int, str | None]:
+        """Prepare test execution by collecting tests and setting up environment.
+
+        Args:
+            target_files: Files or directories to test.
+
+        Raises:
+            ValueError: If tool reference is not set.
+
+        Returns:
+            Tuple[int, int, str | None]: Tuple of (total_available_tests,
+                docker_test_count, original_docker_env).
+        """
+        if self.tool is None:
+            raise ValueError("Tool reference not set on executor")
+
+        # Docker tests are disabled by default and must be explicitly enabled
+        run_docker_tests = self.config.run_docker_tests or False
+
+        # Store original environment state for cleanup
+        original_docker_env = os.environ.get("LINTRO_RUN_DOCKER_TESTS")
+
+        # Collect tests once and get both total count and docker test count
+        # This avoids duplicate pytest --collect-only calls
+        total_available_tests, docker_test_count = collect_tests_once(
+            self.tool,
+            target_files,
+        )
+
+        if run_docker_tests:
+            # Set environment variable to enable Docker tests
+            os.environ["LINTRO_RUN_DOCKER_TESTS"] = "1"
+            # Log that Docker tests are enabled (may take longer) in blue format
+            docker_msg = (
+                f"[LINTRO] Docker tests enabled ({docker_test_count} tests) - "
+                "this may take longer than usual."
+            )
+            logger.info(f"\033[36;1m{docker_msg}\033[0m")
+        else:
+            # Explicitly unset the environment variable to disable Docker tests
+            if "LINTRO_RUN_DOCKER_TESTS" in os.environ:
+                del os.environ["LINTRO_RUN_DOCKER_TESTS"]
+
+            if docker_test_count > 0:
+                # Log that Docker tests are disabled in blue format
+                docker_msg = (
+                    f"[LINTRO] Docker tests disabled "
+                    f"({docker_test_count} tests not collected). "
+                    "Use --enable-docker to include them."
+                )
+                logger.info(f"\033[36;1m{docker_msg}\033[0m")
+
+        return (total_available_tests, docker_test_count, original_docker_env)
+
+    def execute_tests(
+        self,
+        cmd: list[str],
+    ) -> tuple[bool, str, int]:
+        """Execute pytest tests and parse output.
+
+        Args:
+            cmd: Command to execute.
+
+        Raises:
+            ValueError: If tool reference is not set.
+
+        Returns:
+            Tuple[bool, str, int]: Tuple of (success, output, return_code).
+        """
+        if self.tool is None:
+            raise ValueError("Tool reference not set on executor")
+
+        success, output = self.tool._run_subprocess(cmd)
+        # Parse output with actual success status
+        # (pytest returns non-zero on failures)
+        return_code = 0 if success else 1
+        return (success, output, return_code)
+
+    def restore_environment(self, original_docker_env: str | None) -> None:
+        """Restore the original environment state.
+
+        Args:
+            original_docker_env: Original value of LINTRO_RUN_DOCKER_TESTS env var.
+        """
+        # Restore original environment state
+        if original_docker_env is not None:
+            os.environ["LINTRO_RUN_DOCKER_TESTS"] = original_docker_env
+        elif "LINTRO_RUN_DOCKER_TESTS" in os.environ:
+            del os.environ["LINTRO_RUN_DOCKER_TESTS"]

lintro/tools/implementations/pytest/pytest_handlers.py

@@ -0,0 +1,375 @@
+"""Handler functions for pytest tool special modes.
+
+This module contains handler functions extracted from PytestTool to improve
+maintainability and reduce file size. These handlers implement special modes
+like listing plugins, collecting tests, listing fixtures, etc.
+"""
+
+import re
+import shlex
+
+from lintro.models.core.tool_result import ToolResult
+from lintro.tools.implementations.pytest.pytest_utils import (
+    check_plugin_installed,
+    get_pytest_version_info,
+    list_installed_plugins,
+)
+
+
+def handle_list_plugins(tool) -> ToolResult:
+    """Handle list plugins mode.
+
+    Args:
+        tool: PytestTool instance.
+
+    Returns:
+        ToolResult: Results with plugin list.
+    """
+    plugins = list_installed_plugins()
+    version_info = get_pytest_version_info()
+
+    output_lines = [version_info, ""]
+    if plugins:
+        output_lines.append(f"Installed pytest plugins ({len(plugins)}):")
+        for plugin in plugins:
+            output_lines.append(f"  - {plugin['name']} ({plugin['version']})")
+    else:
+        output_lines.append("No pytest plugins found.")
+
+    return ToolResult(
+        name=tool.name,
+        success=True,
+        issues=[],
+        output="\n".join(output_lines),
+        issues_count=0,
+    )
+
+
+def handle_check_plugins(
+    tool,
+    required_plugins: str | None,
+) -> ToolResult:
+    """Handle check plugins mode.
+
+    Args:
+        tool: PytestTool instance.
+        required_plugins: Comma-separated list of required plugin names.
+
+    Returns:
+        ToolResult: Results with plugin check status.
+    """
+    if not required_plugins:
+        return ToolResult(
+            name=tool.name,
+            success=False,
+            issues=[],
+            output=(
+                "Error: required_plugins must be specified " "when check_plugins=True"
+            ),
+            issues_count=0,
+        )
+
+    plugin_list = [p.strip() for p in required_plugins.split(",") if p.strip()]
+    missing_plugins: list[str] = []
+    installed_plugins: list[str] = []
+
+    for plugin in plugin_list:
+        if check_plugin_installed(plugin):
+            installed_plugins.append(plugin)
+        else:
+            missing_plugins.append(plugin)
+
+    output_lines = []
+    if installed_plugins:
+        output_lines.append(f"✓ Installed plugins ({len(installed_plugins)}):")
+        for plugin in installed_plugins:
+            output_lines.append(f"  - {plugin}")
+
+    if missing_plugins:
+        output_lines.append(f"\n✗ Missing plugins ({len(missing_plugins)}):")
+        for plugin in missing_plugins:
+            output_lines.append(f"  - {plugin}")
+        output_lines.append("\nInstall missing plugins with:")
+        quoted_plugins = " ".join(shlex.quote(plugin) for plugin in missing_plugins)
+        output_lines.append(f"  pip install {quoted_plugins}")
+
+    success = len(missing_plugins) == 0
+
+    return ToolResult(
+        name=tool.name,
+        success=success,
+        issues=[],
+        output="\n".join(output_lines) if output_lines else "No plugins specified.",
+        issues_count=len(missing_plugins),
+    )
+
+
+def handle_collect_only(
+    tool,
+    target_files: list[str],
+) -> ToolResult:
+    """Handle collect-only mode.
+
+    Args:
+        tool: PytestTool instance.
+        target_files: Files or directories to collect tests from.
+
+    Returns:
+        ToolResult: Results with collected test list.
+    """
+    try:
+        collect_cmd = tool._get_executable_command(tool_name="pytest")
+        collect_cmd.append("--collect-only")
+        collect_cmd.extend(target_files)
+
+        success, output = tool._run_subprocess(collect_cmd)
+        if not success:
+            return ToolResult(
+                name=tool.name,
+                success=False,
+                issues=[],
+                output=output,
+                issues_count=0,
+            )
+
+        # Parse collected tests from output
+        test_list: list[str] = []
+        for line in output.splitlines():
+            line = line.strip()
+            # Match test collection lines
+            # (e.g., "<Function test_example>" or "test_file.py::test_function")
+            if "<Function" in line or "::" in line:
+                # Extract test identifier
+                if "::" in line:
+                    test_list.append(line.split("::")[-1].strip())
+                elif "<Function" in line:
+                    # Extract function name from <Function test_name>
+                    match = re.search(r"<Function\s+(\w+)>", line)
+                    if match:
+                        test_list.append(match.group(1))
+
+        output_lines = [f"Collected {len(test_list)} test(s):", ""]
+        for test in test_list:
+            output_lines.append(f"  - {test}")
+
+        return ToolResult(
+            name=tool.name,
+            success=True,
+            issues=[],
+            output="\n".join(output_lines),
+            issues_count=0,
+        )
+    except Exception as e:
+        return ToolResult(
+            name=tool.name,
+            success=False,
+            issues=[],
+            output=f"Error collecting tests: {e}",
+            issues_count=0,
+        )
+
+
+def handle_list_fixtures(
+    tool,
+    target_files: list[str],
+) -> ToolResult:
+    """Handle list fixtures mode.
+
+    Args:
+        tool: PytestTool instance.
+        target_files: Files or directories to collect fixtures from.
+
+    Returns:
+        ToolResult: Results with fixture list.
+    """
+    try:
+        fixtures_cmd = tool._get_executable_command(tool_name="pytest")
+        fixtures_cmd.extend(["--fixtures", "-q"])
+        fixtures_cmd.extend(target_files)
+
+        success, output = tool._run_subprocess(fixtures_cmd)
+        if not success:
+            return ToolResult(
+                name=tool.name,
+                success=False,
+                issues=[],
+                output=output,
+                issues_count=0,
+            )
+
+        return ToolResult(
+            name=tool.name,
+            success=True,
+            issues=[],
+            output=output,
+            issues_count=0,
+        )
+    except Exception as e:
+        return ToolResult(
+            name=tool.name,
+            success=False,
+            issues=[],
+            output=f"Error listing fixtures: {e}",
+            issues_count=0,
+        )
+
+
+def handle_fixture_info(
+    tool,
+    fixture_name: str,
+    target_files: list[str],
+) -> ToolResult:
+    """Handle fixture info mode.
+
+    Args:
+        tool: PytestTool instance.
+        fixture_name: Name of fixture to get info for.
+        target_files: Files or directories to search.
+
+    Returns:
+        ToolResult: Results with fixture information.
+    """
+    try:
+        fixtures_cmd = tool._get_executable_command(tool_name="pytest")
+        fixtures_cmd.extend(["--fixtures", "-v"])
+        fixtures_cmd.extend(target_files)
+
+        success, output = tool._run_subprocess(fixtures_cmd)
+        if not success:
+            return ToolResult(
+                name=tool.name,
+                success=False,
+                issues=[],
+                output=output,
+                issues_count=0,
+            )
+
+        # Extract fixture info for the specific fixture
+        lines = output.splitlines()
+        fixture_info_lines: list[str] = []
+        in_fixture = False
+
+        for line in lines:
+            # Check if line starts with fixture name (pytest format)
+            stripped_line = line.strip()
+            if stripped_line.startswith(fixture_name) and (
+                len(stripped_line) == len(fixture_name)
+                or stripped_line[len(fixture_name)] in (" ", ":", "\n")
+            ):
+                in_fixture = True
+                fixture_info_lines.append(line)
+            elif in_fixture:
+                if line.strip() and not line.startswith(" "):
+                    # New fixture or section, stop
+                    break
+                fixture_info_lines.append(line)
+
+        if fixture_info_lines:
+            output_text = "\n".join(fixture_info_lines)
+        else:
+            output_text = f"Fixture '{fixture_name}' not found."
+
+        return ToolResult(
+            name=tool.name,
+            success=len(fixture_info_lines) > 0,
+            issues=[],
+            output=output_text,
+            issues_count=0,
+        )
+    except Exception as e:
+        return ToolResult(
+            name=tool.name,
+            success=False,
+            issues=[],
+            output=f"Error getting fixture info: {e}",
+            issues_count=0,
+        )
+
+
+def handle_list_markers(tool) -> ToolResult:
+    """Handle list markers mode.
+
+    Args:
+        tool: PytestTool instance.
+
+    Returns:
+        ToolResult: Results with marker list.
+    """
+    try:
+        markers_cmd = tool._get_executable_command(tool_name="pytest")
+        markers_cmd.extend(["--markers"])
+
+        success, output = tool._run_subprocess(markers_cmd)
+        if not success:
+            return ToolResult(
+                name=tool.name,
+                success=False,
+                issues=[],
+                output=output,
+                issues_count=0,
+            )
+
+        return ToolResult(
+            name=tool.name,
+            success=True,
+            issues=[],
+            output=output,
+            issues_count=0,
+        )
+    except Exception as e:
+        return ToolResult(
+            name=tool.name,
+            success=False,
+            issues=[],
+            output=f"Error listing markers: {e}",
+            issues_count=0,
+        )
+
+
+def handle_parametrize_help(tool) -> ToolResult:
+    """Handle parametrize help mode.
+
+    Args:
+        tool: PytestTool instance.
+
+    Returns:
+        ToolResult: Results with parametrization help.
+    """
+    help_text = """Pytest Parametrization Help
+
+Parametrization allows you to run the same test with different inputs.
+
+Basic Usage:
+-----------
+Use @pytest.mark.parametrize to provide multiple input values for a test function.
+The test will run once for each set of parameters.
+
+Example:
+@pytest.mark.parametrize("input,expected", [(1, 2), (2, 4), (3, 6)])
+def test_multiply(input, expected):
+    assert input * 2 == expected
+
+Multiple Parameters:
+--------------------
+You can parametrize multiple parameters at once by providing tuples of values.
+
+Using Fixtures with Parametrization:
+-------------------------------------
+Parametrized tests can use fixtures. The parametrization runs for each fixture
+instance, creating a cartesian product of parameters and fixtures.
+
+Multiple Parametrizations:
+--------------------------
+You can stack multiple @pytest.mark.parametrize decorators to create a cartesian
+product of all parameter combinations.
+
+For detailed examples and advanced usage, see:
+https://docs.pytest.org/en/stable/how-to/parametrize.html
+"""
+    return ToolResult(
+        name=tool.name,
+        success=True,
+        issues=[],
+        output=help_text,
+        issues_count=0,
+    )

lintro/tools/implementations/pytest/pytest_option_validators.py

@@ -0,0 +1,212 @@
+"""Option validation functions for pytest tool.
+
+This module contains validation logic extracted from PytestTool.set_options()
+to improve maintainability and reduce file size.
+"""
+
+from lintro.tools.implementations.pytest.pytest_utils import (
+    get_parallel_workers_from_preset,
+)
+
+
+def validate_pytest_options(
+    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,
+) -> None:
+    """Validate pytest-specific options.
+
+    Args:
+        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.
+        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).
+
+    Raises:
+        ValueError: If an option value is invalid.
+    """
+    if verbose is not None and not isinstance(verbose, bool):
+        raise ValueError("verbose must be a boolean")
+
+    if tb is not None and tb not in ("short", "long", "auto", "line", "native"):
+        raise ValueError("tb must be one of: short, long, auto, line, native")
+
+    if maxfail is not None and (not isinstance(maxfail, int) or maxfail <= 0):
+        raise ValueError("maxfail must be a positive integer")
+
+    if no_header is not None and not isinstance(no_header, bool):
+        raise ValueError("no_header must be a boolean")
+
+    if disable_warnings is not None and not isinstance(disable_warnings, bool):
+        raise ValueError("disable_warnings must be a boolean")
+
+    if json_report is not None and not isinstance(json_report, bool):
+        raise ValueError("json_report must be a boolean")
+
+    if junitxml is not None and not isinstance(junitxml, str):
+        raise ValueError("junitxml must be a string")
+
+    if run_docker_tests is not None and not isinstance(run_docker_tests, bool):
+        raise ValueError("run_docker_tests must be a boolean")
+
+    if slow_test_threshold is not None and (
+        not isinstance(slow_test_threshold, (int, float)) or slow_test_threshold < 0
+    ):
+        raise ValueError("slow_test_threshold must be a non-negative number")
+
+    if total_time_warning is not None and (
+        not isinstance(total_time_warning, (int, float)) or total_time_warning < 0
+    ):
+        raise ValueError("total_time_warning must be a non-negative number")
+
+    if workers is not None and not isinstance(workers, str):
+        raise ValueError("workers must be a string (e.g., 'auto', '2', '4')")
+
+    if coverage_threshold is not None and not isinstance(
+        coverage_threshold,
+        (int, float),
+    ):
+        raise ValueError("coverage_threshold must be a number")
+    if coverage_threshold is not None and not (0 <= coverage_threshold <= 100):
+        raise ValueError("coverage_threshold must be between 0 and 100")
+
+    if auto_junitxml is not None and not isinstance(auto_junitxml, bool):
+        raise ValueError("auto_junitxml must be a boolean")
+
+    if detect_flaky is not None and not isinstance(detect_flaky, bool):
+        raise ValueError("detect_flaky must be a boolean")
+
+    if flaky_min_runs is not None and (
+        not isinstance(flaky_min_runs, int) or flaky_min_runs < 1
+    ):
+        raise ValueError("flaky_min_runs must be a positive integer")
+
+    if flaky_failure_rate is not None:
+        if not isinstance(flaky_failure_rate, (int, float)):
+            raise ValueError("flaky_failure_rate must be a number")
+        if not (0 <= flaky_failure_rate <= 1):
+            raise ValueError("flaky_failure_rate must be between 0 and 1")
+
+    if html_report is not None and not isinstance(html_report, str):
+        raise ValueError("html_report must be a string (path to HTML report)")
+
+    if parallel_preset is not None and not isinstance(parallel_preset, str):
+        raise ValueError("parallel_preset must be a string")
+    # Validate preset value
+    if parallel_preset is not None:
+        try:
+            get_parallel_workers_from_preset(parallel_preset)
+        except ValueError as e:
+            raise ValueError(f"Invalid parallel_preset: {e}") from e
+
+    # Validate plugin options
+    if list_plugins is not None and not isinstance(list_plugins, bool):
+        raise ValueError("list_plugins must be a boolean")
+
+    if check_plugins is not None and not isinstance(check_plugins, bool):
+        raise ValueError("check_plugins must be a boolean")
+
+    if required_plugins is not None and not isinstance(required_plugins, str):
+        raise ValueError("required_plugins must be a string")
+
+    # Validate coverage options
+    if coverage_html is not None and not isinstance(coverage_html, str):
+        raise ValueError("coverage_html must be a string")
+
+    if coverage_xml is not None and not isinstance(coverage_xml, str):
+        raise ValueError("coverage_xml must be a string")
+
+    if coverage_report is not None and not isinstance(coverage_report, bool):
+        raise ValueError("coverage_report must be a boolean")
+
+    # Validate discovery and inspection options
+    if collect_only is not None and not isinstance(collect_only, bool):
+        raise ValueError("collect_only must be a boolean")
+
+    if list_fixtures is not None and not isinstance(list_fixtures, bool):
+        raise ValueError("list_fixtures must be a boolean")
+
+    if fixture_info is not None and not isinstance(fixture_info, str):
+        raise ValueError("fixture_info must be a string")
+
+    if list_markers is not None and not isinstance(list_markers, bool):
+        raise ValueError("list_markers must be a boolean")
+
+    if parametrize_help is not None and not isinstance(parametrize_help, bool):
+        raise ValueError("parametrize_help must be a boolean")
+
+    if show_progress is not None and not isinstance(show_progress, bool):
+        raise ValueError("show_progress must be a boolean")
+
+    # Validate plugin-specific options
+    if timeout is not None and (not isinstance(timeout, int) or timeout <= 0):
+        raise ValueError("timeout must be a positive integer (seconds)")
+
+    if reruns is not None and (not isinstance(reruns, int) or reruns < 0):
+        raise ValueError("reruns must be a non-negative integer")
+
+    if reruns_delay is not None and (
+        not isinstance(reruns_delay, int) or reruns_delay < 0
+    ):
+        raise ValueError("reruns_delay must be a non-negative integer (seconds)")