pycmdcheck 0.1.0__py3-none-any.whl

pycmdcheck/checks/tests.py

@@ -0,0 +1,230 @@
+"""Test runner check.
+
+This module provides the TestsCheck class which runs package tests
+using pytest or unittest and reports the results.
+"""
+
+from pathlib import Path
+from typing import Any
+
+from pycmdcheck.checks.base import BaseCheck
+from pycmdcheck.constants import LONG_TIMEOUT, MAX_DETAIL_LINES
+from pycmdcheck.results import CheckResult, CheckStatus
+from pycmdcheck.subprocess_runner import run_tool, sanitize_args, tool_available
+
+
+class TestsCheck(BaseCheck):
+    """Run package tests and report results.
+
+    Executes the package's test suite using the configured test runner
+    (pytest by default) and reports pass/fail status. Supports pytest
+    and unittest runners.
+
+    Attributes:
+        name: The check identifier ("tests").
+        description: Human-readable description of this check.
+
+    Configuration Options:
+        runner (str): Test runner to use ("pytest" or "unittest").
+            Defaults to "pytest".
+        args (list[str]): Additional arguments to pass to the test runner.
+
+    Examples:
+        Run tests with default settings (pytest):
+
+        >>> from pathlib import Path
+        >>> check = TestsCheck()
+        >>> result = check.run(Path("."), {"enabled": True})
+        >>> result.name
+        'tests'
+
+        Configure to use unittest:
+
+        >>> config = {"enabled": True, "runner": "unittest"}
+        >>> result = check.run(Path("."), config)
+
+        Pass additional pytest arguments:
+
+        >>> config = {"enabled": True, "args": ["-x", "--cov"]}
+        >>> result = check.run(Path("."), config)
+    """
+
+    name = "tests"
+    description = "Run package tests (pytest/unittest)"
+
+    def run(self, package_path: Path, config: dict[str, Any]) -> CheckResult:
+        """Run tests and return results.
+
+        Executes the test suite in the package's tests/ or test/ directory.
+        The test runner is determined by the ``runner`` config option.
+
+        Args:
+            package_path: Path to the package directory containing tests.
+            config: Configuration dictionary with options:
+
+                - runner (str): "pytest" or "unittest" (default: "pytest")
+                - args (list[str]): Additional arguments for the runner
+
+        Returns:
+            A CheckResult with:
+
+            - OK status if all tests pass
+            - WARNING status if no tests found
+            - ERROR status if tests fail or runner not installed
+            - SKIPPED status if the test runner is not installed
+        """
+        runner = config.get("runner", "pytest")
+
+        # Check if test directory exists
+        test_dirs = ["tests", "test"]
+        test_dir_found = None
+        for test_dir in test_dirs:
+            if (package_path / test_dir).is_dir():
+                test_dir_found = test_dir
+                break
+
+        # Also check for test files at root
+        test_files = list(package_path.glob("test_*.py"))
+
+        if not test_dir_found and not test_files:
+            return CheckResult(
+                name=self.name,
+                status=CheckStatus.WARNING,
+                message="No tests found",
+                details=["Consider adding tests in a 'tests/' directory"],
+            )
+
+        preamble = [f"Using test runner: {runner}"]
+
+        if runner == "pytest":
+            return self._run_pytest(package_path, config, preamble)
+        elif runner == "unittest":
+            return self._run_unittest(package_path, config, preamble)
+        else:
+            return CheckResult(
+                name=self.name,
+                status=CheckStatus.ERROR,
+                message=f"Unknown test runner: {runner}",
+                details=["Supported runners: pytest, unittest"],
+            )
+
+    def _run_pytest(
+        self, package_path: Path, config: dict[str, Any], preamble: list[str]
+    ) -> CheckResult:
+        """Run pytest."""
+        if not tool_available("pytest"):
+            return CheckResult(
+                name=self.name,
+                status=CheckStatus.SKIPPED,
+                message="pytest not installed",
+                details=["Install pytest: pip install pytest"],
+            )
+
+        args = sanitize_args(config.get("args", []))
+        cmd = ["pytest", "-v", "--tb=short", *args]
+
+        result = run_tool(cmd, cwd=package_path, timeout=LONG_TIMEOUT)
+
+        if result.timed_out:
+            return CheckResult(
+                name=self.name,
+                status=CheckStatus.ERROR,
+                message="Tests timed out",
+                details=[f"Tests took longer than {LONG_TIMEOUT} seconds"],
+            )
+
+        if result.error is not None:
+            return CheckResult(
+                name=self.name,
+                status=CheckStatus.ERROR,
+                message="Failed to run tests",
+                details=[result.error],
+            )
+
+        if result.success:
+            # Parse pytest output for summary
+            details = list(preamble)
+            for line in result.stdout.split("\n"):
+                if "passed" in line or "skipped" in line:
+                    details.append(line.strip())
+                    break
+
+            return CheckResult(
+                name=self.name,
+                status=CheckStatus.OK,
+                message="All tests passed",
+                details=details,
+            )
+
+        # Tests failed
+        output = result.stdout + result.stderr
+        failure_lines: list[str] = []
+        for line in output.split("\n"):
+            if "FAILED" in line or "ERROR" in line:
+                failure_lines.append(line.strip())
+
+        details = [*preamble, *failure_lines[:MAX_DETAIL_LINES]]
+        if len(failure_lines) > MAX_DETAIL_LINES:
+            details.append("... (more failures omitted)")
+
+        return CheckResult(
+            name=self.name,
+            status=CheckStatus.ERROR,
+            message="Tests failed",
+            details=details,
+        )
+
+    def _run_unittest(
+        self, package_path: Path, config: dict[str, Any], preamble: list[str]
+    ) -> CheckResult:
+        """Run unittest discovery."""
+        args = sanitize_args(config.get("args", []))
+        cmd = ["python", "-m", "unittest", "discover", "-v", *args]
+
+        result = run_tool(cmd, cwd=package_path, timeout=LONG_TIMEOUT)
+
+        if result.timed_out:
+            return CheckResult(
+                name=self.name,
+                status=CheckStatus.ERROR,
+                message="Tests timed out",
+                details=[f"Tests took longer than {LONG_TIMEOUT} seconds"],
+            )
+
+        if result.error is not None:
+            return CheckResult(
+                name=self.name,
+                status=CheckStatus.ERROR,
+                message="Failed to run tests",
+                details=[result.error],
+            )
+
+        if result.success:
+            # Parse output for test count (unittest outputs to stderr)
+            details = list(preamble)
+            for line in result.stderr.split("\n"):
+                if "Ran" in line:
+                    details.append(line.strip())
+                    break
+
+            return CheckResult(
+                name=self.name,
+                status=CheckStatus.OK,
+                message="All tests passed",
+                details=details,
+            )
+
+        # Parse failures from stderr
+        failure_lines: list[str] = []
+        for line in result.stderr.split("\n"):
+            if "FAIL:" in line or "ERROR:" in line:
+                failure_lines.append(line.strip())
+
+        details = [*preamble, *failure_lines[:MAX_DETAIL_LINES]]
+
+        return CheckResult(
+            name=self.name,
+            status=CheckStatus.ERROR,
+            message="Tests failed",
+            details=details,
+        )

pycmdcheck/checks/typing.py

@@ -0,0 +1,257 @@
+"""Type checking with configurable backends.
+
+This module provides the TypingCheck class which runs static type
+checking tools (mypy or pyright) on the package and reports any errors.
+"""
+
+from pathlib import Path
+from typing import Any
+
+from pycmdcheck.checks.base import BaseCheck
+from pycmdcheck.constants import LONG_TIMEOUT, MAX_DETAIL_LINES
+from pycmdcheck.package_layout import PackageLayout
+from pycmdcheck.results import CheckResult, CheckStatus
+from pycmdcheck.subprocess_runner import run_tool, sanitize_args, tool_available
+
+
+class TypingCheck(BaseCheck):
+    """Run type checking tools on the package.
+
+    Executes a configurable static type checker to verify type
+    annotations. Supports mypy (default) and pyright.
+
+    Attributes:
+        name: The check identifier ("typing").
+        description: Human-readable description of this check.
+        SUPPORTED_TOOLS: List of supported type checking tools.
+
+    Configuration Options:
+        tool (str): Type checker to use ("mypy" or "pyright").
+            Defaults to "mypy".
+        strict (bool): Whether to enable strict mode. Defaults to False.
+        args (list[str]): Additional arguments to pass to the type checker.
+
+    Examples:
+        Run type checking with default settings (mypy):
+
+        >>> from pathlib import Path
+        >>> check = TypingCheck()
+        >>> result = check.run(Path("."), {"enabled": True})
+        >>> result.name
+        'typing'
+
+        Configure to use pyright:
+
+        >>> config = {"enabled": True, "tool": "pyright"}
+        >>> result = check.run(Path("."), config)
+
+        Enable strict mode:
+
+        >>> config = {"enabled": True, "strict": True}
+        >>> result = check.run(Path("."), config)
+    """
+
+    name = "typing"
+    description = "Run type checking (mypy/pyright)"
+
+    SUPPORTED_TOOLS = ["mypy", "pyright"]
+
+    def run(self, package_path: Path, config: dict[str, Any]) -> CheckResult:
+        """Run type checking on the package.
+
+        Executes the configured type checker and collects any errors found.
+        Errors are reported in the result details (limited to first 10).
+
+        Args:
+            package_path: Path to the package directory to check.
+            config: Configuration dictionary with options:
+
+                - tool (str): "mypy" or "pyright" (default: "mypy")
+                - strict (bool): Enable strict mode (default: False)
+                - args (list[str]): Additional arguments for the checker
+
+        Returns:
+            A CheckResult with:
+
+            - OK status if no type errors found
+            - ERROR status if type errors found or checker fails
+            - SKIPPED status if the type checker is not installed
+        """
+        tool = config.get("tool", "mypy")
+
+        if tool not in self.SUPPORTED_TOOLS:
+            return CheckResult(
+                name=self.name,
+                status=CheckStatus.ERROR,
+                message=f"Unsupported type checker: {tool}",
+                details=[f"Supported tools: {', '.join(self.SUPPORTED_TOOLS)}"],
+            )
+
+        preamble = [f"Using type checker: {tool}"]
+
+        if tool == "mypy":
+            return self._run_mypy(package_path, config, preamble)
+        else:  # pyright
+            return self._run_pyright(package_path, config, preamble)
+
+    def _run_mypy(
+        self, package_path: Path, config: dict[str, Any], preamble: list[str]
+    ) -> CheckResult:
+        """Run mypy type checker."""
+        if not tool_available("mypy"):
+            return CheckResult(
+                name=self.name,
+                status=CheckStatus.SKIPPED,
+                message="mypy not installed",
+                details=["Install mypy: pip install mypy"],
+            )
+
+        # Target the discovered package(s)/module(s) rather than ".", which on
+        # flat/single-module layouts makes mypy scan tests/build/etc. and emit
+        # spurious "Duplicate module" discovery failures. mypy auto-detects the
+        # base directory by walking up past __init__.py, so module names stay
+        # correct (we deliberately do NOT pass --explicit-package-bases, which
+        # would mis-root packages relative to the cwd).
+        layout = PackageLayout(package_path)
+        targets = [str(p) for p in layout.package_dirs]
+        targets += [str(m) for m in layout.top_level_modules()]
+        if not targets:
+            src_dir = package_path / "src"
+            targets = [str(src_dir) if src_dir.is_dir() else "."]
+
+        args = sanitize_args(config.get("args", []))
+        strict = config.get("strict", False)
+
+        cmd = ["mypy", "--namespace-packages", *targets]
+        if strict:
+            cmd.append("--strict")
+        cmd.extend(args)
+
+        result = run_tool(cmd, cwd=package_path, timeout=LONG_TIMEOUT)
+
+        if result.timed_out:
+            return CheckResult(
+                name=self.name,
+                status=CheckStatus.ERROR,
+                message="Type checking timed out",
+                details=[f"Type checking took longer than {LONG_TIMEOUT} seconds"],
+            )
+
+        if result.error is not None:
+            return CheckResult(
+                name=self.name,
+                status=CheckStatus.ERROR,
+                message="Failed to run mypy",
+                details=[result.error],
+            )
+
+        stdout = result.stdout.strip()
+
+        if result.success:
+            # Check for "Success" message
+            if "Success" in stdout or not stdout:
+                return CheckResult(
+                    name=self.name,
+                    status=CheckStatus.OK,
+                    message="No type errors found",
+                    details=list(preamble),
+                )
+
+        # mypy exit code 2 is a fatal/discovery/config error (e.g. duplicate
+        # modules, missing config) — not a type-error finding.
+        if result.returncode == 2:
+            detail_lines = (result.output or "").strip().splitlines()
+            return CheckResult(
+                name=self.name,
+                status=CheckStatus.WARNING,
+                message="mypy could not analyze the package (configuration/layout)",
+                details=[*preamble, *detail_lines[:MAX_DETAIL_LINES]],
+            )
+
+        # Parse mypy output for errors
+        errors = []
+        for line in stdout.split("\n"):
+            if ": error:" in line:
+                errors.append(line.strip())
+
+        if not errors and "error:" in stdout:
+            errors = [line.strip() for line in stdout.split("\n") if line.strip()]
+
+        details = [*preamble, *errors[:MAX_DETAIL_LINES]]
+
+        if len(errors) > MAX_DETAIL_LINES:
+            details.append(f"... and {len(errors) - MAX_DETAIL_LINES} more errors")
+
+        error_count = len(errors) if errors else "some"
+        return CheckResult(
+            name=self.name,
+            status=CheckStatus.ERROR,
+            message=f"Found {error_count} type error(s)",
+            details=details,
+        )
+
+    def _run_pyright(
+        self, package_path: Path, config: dict[str, Any], preamble: list[str]
+    ) -> CheckResult:
+        """Run pyright type checker."""
+        if not tool_available("pyright"):
+            return CheckResult(
+                name=self.name,
+                status=CheckStatus.SKIPPED,
+                message="pyright not installed",
+                details=["Install pyright: pip install pyright"],
+            )
+
+        args = sanitize_args(config.get("args", []))
+        strict = config.get("strict", False)
+
+        cmd = ["pyright"]
+        if strict:
+            cmd.append("--strict")
+        cmd.extend(args)
+
+        result = run_tool(cmd, cwd=package_path, timeout=LONG_TIMEOUT)
+
+        if result.timed_out:
+            return CheckResult(
+                name=self.name,
+                status=CheckStatus.ERROR,
+                message="Type checking timed out",
+                details=[f"Type checking took longer than {LONG_TIMEOUT} seconds"],
+            )
+
+        if result.error is not None:
+            return CheckResult(
+                name=self.name,
+                status=CheckStatus.ERROR,
+                message="Failed to run pyright",
+                details=[result.error],
+            )
+
+        if result.success:
+            return CheckResult(
+                name=self.name,
+                status=CheckStatus.OK,
+                message="No type errors found",
+                details=list(preamble),
+            )
+
+        # Parse pyright output
+        stdout = result.stdout.strip()
+        errors = []
+        for line in stdout.split("\n"):
+            if " - error:" in line or " - warning:" in line:
+                errors.append(line.strip())
+
+        details = [*preamble, *errors[:MAX_DETAIL_LINES]]
+
+        if len(errors) > MAX_DETAIL_LINES:
+            details.append(f"... and {len(errors) - MAX_DETAIL_LINES} more errors")
+
+        error_count = len(errors) if errors else "some"
+        return CheckResult(
+            name=self.name,
+            status=CheckStatus.ERROR,
+            message=f"Found {error_count} type error(s)",
+            details=details,
+        )

pycmdcheck/checks/urls.py

@@ -0,0 +1,124 @@
+"""URL reachability check.
+
+Validates that URLs declared in package metadata are reachable.
+"""
+
+import logging
+import urllib.error
+import urllib.request
+from pathlib import Path
+from typing import Any
+
+from pycmdcheck.checks.base import BaseCheck
+from pycmdcheck.constants import MAX_DETAIL_LINES, MAX_URL_CHECKS, URL_TIMEOUT
+from pycmdcheck.pyproject_reader import read_pyproject
+from pycmdcheck.results import CheckResult, CheckStatus
+
+logger = logging.getLogger(__name__)
+
+
+class URLsCheck(BaseCheck):
+    """Check that project URLs in metadata are reachable.
+
+    Extracts URLs from ``[project.urls]`` in pyproject.toml and
+    validates each with an HTTP HEAD request.
+
+    Attributes:
+        name: The check identifier ("urls").
+        description: Human-readable description of this check.
+    """
+
+    name = "urls"
+    description = "Validate project URLs are reachable"
+
+    def run(self, package_path: Path, config: dict[str, Any]) -> CheckResult:
+        """Check URL reachability for project metadata URLs.
+
+        Args:
+            package_path: Path to the package directory to check.
+            config: Configuration dictionary for this check.
+                Supports ``timeout`` (int) to override URL_TIMEOUT.
+
+        Returns:
+            A CheckResult with:
+
+            - OK status if all URLs are reachable
+            - WARNING status if some URLs are unreachable
+            - NOTE status if no URLs found in metadata
+        """
+        details: list[str] = []
+        timeout = config.get("timeout", URL_TIMEOUT)
+
+        pyproject = read_pyproject(package_path)
+        if pyproject is None:
+            return CheckResult(
+                name=self.name,
+                status=CheckStatus.NOTE,
+                message="No pyproject.toml found",
+                details=["Cannot check URLs without pyproject.toml"],
+            )
+
+        project = pyproject.get("project", {})
+        urls = project.get("urls", {})
+
+        if not urls:
+            return CheckResult(
+                name=self.name,
+                status=CheckStatus.NOTE,
+                message="No project URLs defined",
+                details=[
+                    "Add [project.urls] to pyproject.toml",
+                    'Example: Homepage = "https://github.com/user/project"',
+                ],
+            )
+
+        unreachable: list[str] = []
+        checked = 0
+
+        for label, url in list(urls.items())[:MAX_URL_CHECKS]:
+            checked += 1
+            reachable, error = self._check_url(url, timeout)
+            if reachable:
+                details.append(f"{label}: {url} (OK)")
+            else:
+                unreachable.append(label)
+                details.append(f"{label}: {url} (FAILED: {error})")
+
+        if unreachable:
+            return CheckResult(
+                name=self.name,
+                status=CheckStatus.WARNING,
+                message=(f"{len(unreachable)} of {checked} URL(s) unreachable"),
+                details=details[:MAX_DETAIL_LINES],
+            )
+
+        return CheckResult(
+            name=self.name,
+            status=CheckStatus.OK,
+            message=f"All {checked} project URL(s) reachable",
+            details=details[:MAX_DETAIL_LINES],
+        )
+
+    def _check_url(self, url: str, timeout: int) -> tuple[bool, str | None]:
+        """Check if a URL is reachable via HTTP HEAD then GET.
+
+        Returns:
+            A tuple of (reachable, error_message).
+        """
+        for method in ("HEAD", "GET"):
+            try:
+                req = urllib.request.Request(url, method=method)
+                req.add_header("User-Agent", "pycmdcheck/0.1")
+                with urllib.request.urlopen(req, timeout=timeout) as resp:
+                    if resp.status < 400:
+                        return True, None
+            except urllib.error.HTTPError as e:
+                if method == "HEAD" and e.code == 405:
+                    continue  # Try GET instead
+                return False, f"HTTP {e.code}"
+            except urllib.error.URLError as e:
+                return False, str(e.reason)
+            except (OSError, ValueError) as e:
+                return False, str(e)
+
+        return False, "All methods failed"