codeowners-coverage 0.3.0__tar.gz → 0.3.1__tar.gz

{codeowners_coverage-0.3.0 → codeowners_coverage-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeowners-coverage
-Version: 0.3.0
+Version: 0.3.1
 Summary: Measure and enforce CODEOWNERS coverage
 Author-email: Sentry Team <hello@sentry.io>
 License: Apache-2.0

{codeowners_coverage-0.3.0 → codeowners_coverage-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codeowners-coverage"
-version = "0.3.0"
+version = "0.3.1"
 description = "Measure and enforce CODEOWNERS coverage"
 readme = "README.md"
 requires-python = ">=3.9"

{codeowners_coverage-0.3.0 → codeowners_coverage-0.3.1}/src/codeowners_coverage/__init__.py

@@ -1,6 +1,6 @@
 """CODEOWNERS coverage checking tool."""
 
-__version__ = "0.3.0"
+__version__ = "0.3.1"
 
 from .checker import CoverageChecker
 from .config import Config

{codeowners_coverage-0.3.0 → codeowners_coverage-0.3.1}/src/codeowners_coverage/cli.py

@@ -30,7 +30,12 @@ def cli() -> None:
 @click.option("--json", "output_json", is_flag=True, help="Output JSON format")
 @click.option("--files", multiple=True, help="Specific files to check")
 @click.option("--config", default=".codeowners-config.yml", help="Config file path")
-def check(output_json: bool, files: Tuple[str, ...], config: str) -> None:
+@click.option(
+    "--allow-dirty-baseline",
+    is_flag=True,
+    help="Don't fail when baseline contains entries that are now covered",
+)
+def check(output_json: bool, files: Tuple[str, ...], config: str, allow_dirty_baseline: bool) -> None:
     """
     Check CODEOWNERS coverage.
 
@@ -48,24 +53,21 @@ def check(output_json: bool, files: Tuple[str, ...], config: str) -> None:
         file_list: List[str] | None = list(files) if files else None
         result = checker.check_coverage(file_list)
 
-        if output_json:
-            click.echo(json.dumps(result, indent=2))
-        else:
-            _print_human_readable_result(result)
-
-        # Exit with error if there are new uncovered files
-        if result["uncovered_files"]:
-            sys.exit(1)
-
-        # Exit with code 2 if baseline can be reduced (positive signal)
-        # Check if any baseline entries (literal paths or glob patterns)
-        # no longer match any uncovered files
+        # Calculate unused baseline entries early
         loaded_baseline = checker._load_baseline()
         baseline_matched = cast(List[str], result["baseline_files"])
         unused_entries = loaded_baseline.get_unused_entries(baseline_matched)
 
-        if unused_entries:
-            if not output_json:
+        # Output results
+        if output_json:
+            json_output = result.copy()
+            json_output["unused_baseline_entries"] = unused_entries
+            click.echo(json.dumps(json_output, indent=2))
+        else:
+            _print_human_readable_result(result)
+
+            # Print unused entries message in human-readable mode
+            if unused_entries:
                 click.echo(f"\n🎉 Great news! {len(unused_entries)} baseline entries can be removed:")
                 for entry in unused_entries[:10]:
                     click.echo(f"  - {entry}")
@@ -73,6 +75,14 @@ def check(output_json: bool, files: Tuple[str, ...], config: str) -> None:
                     click.echo(f"  ... and {len(unused_entries) - 10} more")
                 click.echo("\nThese entries now have CODEOWNERS coverage! Update the baseline:")
                 click.echo("  codeowners-coverage baseline")
+
+        # Exit with error if there are new uncovered files
+        if result["uncovered_files"]:
+            sys.exit(1)
+
+        # Exit with code 2 if baseline can be reduced (positive signal)
+        # Only exit with code 2 if baseline is dirty AND flag is not set
+        if unused_entries and not allow_dirty_baseline:
             sys.exit(2)
 
     except FileNotFoundError as e:
@@ -207,9 +217,8 @@ def suggest(
         from .git_analyzer import GitHistoryAnalyzer
         from .github_client import GitHubClient
         from .matcher import CodeOwnersPatternMatcher
-        from .ollama_matcher import OllamaLLMMatcher, TeamSuggestion
-        from .suggest_cache import SuggestCache
-        from .suggester import OwnershipSuggester, SuggestionResult
+        from .ollama_matcher import OllamaLLMMatcher
+        from .suggester import OwnershipSuggester
 
         # Load config
         cfg = Config.load(config)

{codeowners_coverage-0.3.0 → codeowners_coverage-0.3.1}/src/codeowners_coverage.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeowners-coverage
-Version: 0.3.0
+Version: 0.3.1
 Summary: Measure and enforce CODEOWNERS coverage
 Author-email: Sentry Team <hello@sentry.io>
 License: Apache-2.0

{codeowners_coverage-0.3.0 → codeowners_coverage-0.3.1}/src/codeowners_coverage.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ src/codeowners_coverage.egg-info/entry_points.txt
 src/codeowners_coverage.egg-info/requires.txt
 src/codeowners_coverage.egg-info/top_level.txt
 tests/test_checker.py
+tests/test_cli.py
 tests/test_config.py
 tests/test_directory_consolidator.py
 tests/test_git_analyzer.py

codeowners_coverage-0.3.1/tests/test_cli.py

@@ -0,0 +1,228 @@
+"""Tests for CLI functionality."""
+
+from __future__ import annotations
+
+import json
+import tempfile
+from pathlib import Path
+from unittest.mock import patch
+
+from click.testing import CliRunner
+
+from codeowners_coverage.cli import cli
+
+
+def test_check_dirty_baseline_without_flag_exits_2() -> None:
+    """Test that check exits with code 2 when baseline is dirty (default behavior)."""
+    runner = CliRunner()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        # Create CODEOWNERS file
+        codeowners_path = Path(tmpdir) / "CODEOWNERS"
+        codeowners_path.write_text("*.py @python-team\n")
+
+        # Create baseline with an entry that now has coverage
+        baseline_path = Path(tmpdir) / "baseline.txt"
+        baseline_path.write_text("covered.py\n")
+
+        # Create config
+        config_path = Path(tmpdir) / ".codeowners-config.yml"
+        config_path.write_text(
+            f"codeowners_path: {codeowners_path}\n"
+            f"baseline_path: {baseline_path}\n"
+            f"exclusions: []\n"
+        )
+
+        # Mock get_repository_files to return empty (all files covered)
+        with patch(
+            "codeowners_coverage.checker.CoverageChecker.get_repository_files",
+            return_value=["covered.py"],
+        ):
+            result = runner.invoke(cli, ["check", "--config", str(config_path)])
+
+        # Should exit with code 2 (baseline can be reduced)
+        assert result.exit_code == 2
+        assert "baseline entries can be removed" in result.output
+
+
+def test_check_dirty_baseline_with_flag_exits_0() -> None:
+    """Test that check exits with code 0 when baseline is dirty but flag is set."""
+    runner = CliRunner()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        # Create CODEOWNERS file
+        codeowners_path = Path(tmpdir) / "CODEOWNERS"
+        codeowners_path.write_text("*.py @python-team\n")
+
+        # Create baseline with an entry that now has coverage
+        baseline_path = Path(tmpdir) / "baseline.txt"
+        baseline_path.write_text("covered.py\n")
+
+        # Create config
+        config_path = Path(tmpdir) / ".codeowners-config.yml"
+        config_path.write_text(
+            f"codeowners_path: {codeowners_path}\n"
+            f"baseline_path: {baseline_path}\n"
+            f"exclusions: []\n"
+        )
+
+        # Mock get_repository_files to return covered files
+        with patch(
+            "codeowners_coverage.checker.CoverageChecker.get_repository_files",
+            return_value=["covered.py"],
+        ):
+            result = runner.invoke(
+                cli, ["check", "--config", str(config_path), "--allow-dirty-baseline"]
+            )
+
+        # Should exit with code 0 (success despite dirty baseline)
+        assert result.exit_code == 0
+        assert "baseline entries can be removed" in result.output
+
+
+def test_check_clean_baseline_with_flag_exits_0() -> None:
+    """Test that check exits with code 0 when baseline is clean (with or without flag)."""
+    runner = CliRunner()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        # Create CODEOWNERS file
+        codeowners_path = Path(tmpdir) / "CODEOWNERS"
+        codeowners_path.write_text("*.py @python-team\n")
+
+        # Create empty baseline
+        baseline_path = Path(tmpdir) / "baseline.txt"
+        baseline_path.write_text("")
+
+        # Create config
+        config_path = Path(tmpdir) / ".codeowners-config.yml"
+        config_path.write_text(
+            f"codeowners_path: {codeowners_path}\n"
+            f"baseline_path: {baseline_path}\n"
+            f"exclusions: []\n"
+        )
+
+        # Mock get_repository_files to return covered files
+        with patch(
+            "codeowners_coverage.checker.CoverageChecker.get_repository_files",
+            return_value=["covered.py"],
+        ):
+            result = runner.invoke(
+                cli, ["check", "--config", str(config_path), "--allow-dirty-baseline"]
+            )
+
+        # Should exit with code 0
+        assert result.exit_code == 0
+        assert "baseline entries can be removed" not in result.output
+
+
+def test_check_json_output_includes_unused_baseline_entries() -> None:
+    """Test that JSON output includes unused_baseline_entries field."""
+    runner = CliRunner()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        # Create CODEOWNERS file
+        codeowners_path = Path(tmpdir) / "CODEOWNERS"
+        codeowners_path.write_text("*.py @python-team\n")
+
+        # Create baseline with entries that now have coverage
+        baseline_path = Path(tmpdir) / "baseline.txt"
+        baseline_path.write_text("covered1.py\ncovered2.py\n")
+
+        # Create config
+        config_path = Path(tmpdir) / ".codeowners-config.yml"
+        config_path.write_text(
+            f"codeowners_path: {codeowners_path}\n"
+            f"baseline_path: {baseline_path}\n"
+            f"exclusions: []\n"
+        )
+
+        # Mock get_repository_files to return covered files
+        with patch(
+            "codeowners_coverage.checker.CoverageChecker.get_repository_files",
+            return_value=["covered1.py", "covered2.py"],
+        ):
+            result = runner.invoke(
+                cli, ["check", "--config", str(config_path), "--json"]
+            )
+
+        # Parse JSON output
+        output = json.loads(result.output)
+
+        # Should include unused_baseline_entries
+        assert "unused_baseline_entries" in output
+        assert "covered1.py" in output["unused_baseline_entries"]
+        assert "covered2.py" in output["unused_baseline_entries"]
+
+
+def test_check_new_uncovered_takes_precedence_over_dirty_baseline() -> None:
+    """Test that new uncovered files cause exit 1 even with --allow-dirty-baseline."""
+    runner = CliRunner()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        # Create CODEOWNERS file
+        codeowners_path = Path(tmpdir) / "CODEOWNERS"
+        codeowners_path.write_text("*.py @python-team\n")
+
+        # Create baseline with an entry that now has coverage
+        baseline_path = Path(tmpdir) / "baseline.txt"
+        baseline_path.write_text("covered.py\n")
+
+        # Create config
+        config_path = Path(tmpdir) / ".codeowners-config.yml"
+        config_path.write_text(
+            f"codeowners_path: {codeowners_path}\n"
+            f"baseline_path: {baseline_path}\n"
+            f"exclusions: []\n"
+        )
+
+        # Mock get_repository_files to return covered + new uncovered file
+        with patch(
+            "codeowners_coverage.checker.CoverageChecker.get_repository_files",
+            return_value=["covered.py", "new_uncovered.txt"],
+        ):
+            result = runner.invoke(
+                cli, ["check", "--config", str(config_path), "--allow-dirty-baseline"]
+            )
+
+        # Should exit with code 1 (new uncovered files)
+        assert result.exit_code == 1
+        assert "new_uncovered.txt" in result.output
+
+
+def test_check_json_output_with_clean_baseline() -> None:
+    """Test that JSON output includes empty unused_baseline_entries when baseline is clean."""
+    runner = CliRunner()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        # Create CODEOWNERS file
+        codeowners_path = Path(tmpdir) / "CODEOWNERS"
+        codeowners_path.write_text("*.py @python-team\n")
+
+        # Create baseline with entries still uncovered
+        baseline_path = Path(tmpdir) / "baseline.txt"
+        baseline_path.write_text("still_uncovered.txt\n")
+
+        # Create config
+        config_path = Path(tmpdir) / ".codeowners-config.yml"
+        config_path.write_text(
+            f"codeowners_path: {codeowners_path}\n"
+            f"baseline_path: {baseline_path}\n"
+            f"exclusions: []\n"
+        )
+
+        # Mock get_repository_files to return baseline file (still uncovered)
+        with patch(
+            "codeowners_coverage.checker.CoverageChecker.get_repository_files",
+            return_value=["covered.py", "still_uncovered.txt"],
+        ):
+            result = runner.invoke(
+                cli, ["check", "--config", str(config_path), "--json"]
+            )
+
+        # Parse JSON output
+        output = json.loads(result.output)
+
+        # Should include empty unused_baseline_entries
+        assert "unused_baseline_entries" in output
+        assert output["unused_baseline_entries"] == []
+        assert result.exit_code == 0