GRM-45: feat: add self-updating quality badges to README

2026-06-21 22:30:05 +00:00
parent 402e2dce7e
commit 54a584d609
6 changed files with 506 additions and 0 deletions
@@ -0,0 +1,259 @@
+"""Unit tests for scripts/generate_badges.py."""
+
+import json
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+from click.testing import CliRunner
+
+from scripts.generate_badges import (
+    cli,
+    coverage_color,
+    doc_coverage_color,
+    extract_coverage,
+    extract_doc_coverage,
+    extract_test_count,
+    generate_badges,
+    make_badge,
+    read_version,
+    run_command,
+)
+
+
+class TestRunCommand:
+    @patch("scripts.generate_badges.subprocess.run")
+    def test_returns_returncode_stdout_stderr(self, mock_run: MagicMock) -> None:
+        mock_run.return_value = MagicMock(returncode=0, stdout="out", stderr="err")
+        rc, out, err = run_command(["echo", "hello"])
+        assert rc == 0
+        assert out == "out"
+        assert err == "err"
+        mock_run.assert_called_once()
+
+
+class TestMakeBadge:
+    def test_creates_valid_badge_dict(self) -> None:
+        badge = make_badge("coverage", "100%", "brightgreen")
+        assert badge == {
+            "schemaVersion": 1,
+            "label": "coverage",
+            "message": "100%",
+            "color": "brightgreen",
+        }
+
+
+class TestExtractCoverage:
+    def test_extracts_from_total_line(self) -> None:
+        output = (
+            "src/gitea_runner_manager/cli.py     118      0   100%\n"
+            "TOTAL                                          1798      0   100.00%\n"
+        )
+        assert extract_coverage(output) == 100.0
+
+    def test_extracts_partial_coverage(self) -> None:
+        output = "TOTAL                                          100     20   80.00%\n"
+        assert extract_coverage(output) == 80.0
+
+    def test_returns_none_when_no_match(self) -> None:
+        assert extract_coverage("no coverage here") is None
+
+
+class TestExtractTestCount:
+    def test_extracts_passed_count(self) -> None:
+        assert extract_test_count("543 passed in 2.32s") == 543
+
+    def test_extracts_with_warnings(self) -> None:
+        assert extract_test_count("543 passed, 1 warning in 2.32s") == 543
+
+    def test_returns_none_when_no_match(self) -> None:
+        assert extract_test_count("no tests here") is None
+
+
+class TestExtractDocCoverage:
+    def test_extracts_percentage(self) -> None:
+        output = "\nDoc coverage: 20/20 (100%)"
+        assert extract_doc_coverage(output) == 100
+
+    def test_extracts_partial(self) -> None:
+        output = "\nDoc coverage: 18/20 (90%)"
+        assert extract_doc_coverage(output) == 90
+
+    def test_returns_none_when_no_match(self) -> None:
+        assert extract_doc_coverage("no doc coverage here") is None
+
+
+class TestCoverageColor:
+    def test_100_is_brightgreen(self) -> None:
+        assert coverage_color(100.0) == "brightgreen"
+
+    def test_90_is_green(self) -> None:
+        assert coverage_color(90.0) == "green"
+
+    def test_80_is_yellowgreen(self) -> None:
+        assert coverage_color(80.0) == "yellowgreen"
+
+    def test_70_is_yellow(self) -> None:
+        assert coverage_color(70.0) == "yellow"
+
+    def test_60_is_orange(self) -> None:
+        assert coverage_color(60.0) == "orange"
+
+    def test_below_60_is_red(self) -> None:
+        assert coverage_color(50.0) == "red"
+
+
+class TestDocCoverageColor:
+    def test_100_is_brightgreen(self) -> None:
+        assert doc_coverage_color(100) == "brightgreen"
+
+    def test_90_is_green(self) -> None:
+        assert doc_coverage_color(90) == "green"
+
+    def test_80_is_yellowgreen(self) -> None:
+        assert doc_coverage_color(80) == "yellowgreen"
+
+    def test_70_is_yellow(self) -> None:
+        assert doc_coverage_color(70) == "yellow"
+
+    def test_below_70_is_orange(self) -> None:
+        assert doc_coverage_color(60) == "orange"
+
+
+class TestReadVersion:
+    def test_reads_version_from_init(self) -> None:
+        with patch("scripts.generate_badges.INIT_FILE") as mock_file:
+            mock_file.read_text.return_value = '__version__ = "0.5.0"\n'
+            assert read_version() == "0.5.0"
+
+    def test_returns_unknown_when_no_version(self) -> None:
+        with patch("scripts.generate_badges.INIT_FILE") as mock_file:
+            mock_file.read_text.return_value = "no version here\n"
+            assert read_version() == "unknown"
+
+
+class TestGenerateBadges:
+    @patch("scripts.generate_badges.run_command")
+    @patch("scripts.generate_badges.read_version", return_value="0.5.0")
+    @patch("scripts.generate_badges.extract_coverage", return_value=100.0)
+    @patch("scripts.generate_badges.extract_test_count", return_value=543)
+    @patch("scripts.generate_badges.extract_doc_coverage", return_value=100)
+    def test_generates_all_badge_files(
+        self,
+        mock_doc_cov: MagicMock,
+        mock_test_count: MagicMock,
+        mock_cov: MagicMock,
+        mock_version: MagicMock,
+        mock_run: MagicMock,
+        tmp_path: Path,
+    ) -> None:
+        # run_command is called for pytest, doc_coverage, ruff, ruff format, pyright, bandit
+        mock_run.return_value = (0, "output", "")
+        badges = generate_badges(tmp_path)
+
+        # Verify all expected badges are generated
+        expected = {"coverage", "tests", "docs", "quality", "version", "python"}
+        assert set(badges.keys()) == expected
+
+        # Verify JSON files were written
+        for name in expected:
+            json_file = tmp_path / f"{name}.json"
+            assert json_file.exists()
+            data = json.loads(json_file.read_text())
+            assert data["schemaVersion"] == 1
+            assert "label" in data
+            assert "message" in data
+            assert "color" in data
+
+    @patch("scripts.generate_badges.run_command")
+    @patch("scripts.generate_badges.read_version", return_value="0.5.0")
+    @patch("scripts.generate_badges.extract_coverage", return_value=100.0)
+    @patch("scripts.generate_badges.extract_test_count", return_value=543)
+    @patch("scripts.generate_badges.extract_doc_coverage", return_value=100)
+    def test_quality_badge_pass_when_all_lint_passes(
+        self,
+        mock_doc_cov: MagicMock,
+        mock_test_count: MagicMock,
+        mock_cov: MagicMock,
+        mock_version: MagicMock,
+        mock_run: MagicMock,
+        tmp_path: Path,
+    ) -> None:
+        mock_run.return_value = (0, "output", "")
+        badges = generate_badges(tmp_path)
+        assert badges["quality"]["message"] == "A"
+        assert badges["quality"]["color"] == "brightgreen"
+
+    @patch("scripts.generate_badges.run_command")
+    @patch("scripts.generate_badges.read_version", return_value="0.5.0")
+    @patch("scripts.generate_badges.extract_coverage", return_value=100.0)
+    @patch("scripts.generate_badges.extract_test_count", return_value=543)
+    @patch("scripts.generate_badges.extract_doc_coverage", return_value=100)
+    def test_quality_badge_fails_when_lint_fails(
+        self,
+        mock_doc_cov: MagicMock,
+        mock_test_count: MagicMock,
+        mock_cov: MagicMock,
+        mock_version: MagicMock,
+        mock_run: MagicMock,
+        tmp_path: Path,
+    ) -> None:
+        # First call (pytest) succeeds, second (doc_coverage) succeeds,
+        # third (ruff check) fails
+        mock_run.side_effect = [
+            (0, "output", ""),
+            (0, "output", ""),
+            (1, "error", ""),
+            (0, "output", ""),
+            (0, "output", ""),
+            (0, "output", ""),
+        ]
+        badges = generate_badges(tmp_path)
+        assert badges["quality"]["message"] == "F"
+        assert badges["quality"]["color"] == "red"
+
+    @patch("scripts.generate_badges.run_command")
+    @patch("scripts.generate_badges.read_version", return_value="0.5.0")
+    @patch("scripts.generate_badges.extract_coverage", return_value=None)
+    @patch("scripts.generate_badges.extract_test_count", return_value=None)
+    @patch("scripts.generate_badges.extract_doc_coverage", return_value=None)
+    def test_badges_show_unknown_when_extraction_fails(
+        self,
+        mock_doc_cov: MagicMock,
+        mock_test_count: MagicMock,
+        mock_cov: MagicMock,
+        mock_version: MagicMock,
+        mock_run: MagicMock,
+        tmp_path: Path,
+    ) -> None:
+        mock_run.return_value = (1, "garbled output", "")
+        badges = generate_badges(tmp_path)
+        assert badges["coverage"]["message"] == "unknown"
+        assert badges["coverage"]["color"] == "red"
+        assert badges["tests"]["message"] == "unknown"
+        assert badges["tests"]["color"] == "red"
+        assert badges["docs"]["message"] == "unknown"
+        assert badges["docs"]["color"] == "red"
+
+
+class TestCli:
+    @patch("scripts.generate_badges.generate_badges")
+    def test_cli_generates_badges(self, mock_gen: MagicMock, tmp_path: Path) -> None:
+        mock_gen.return_value = {
+            "coverage": make_badge("coverage", "100%", "brightgreen"),
+            "tests": make_badge("tests", "543 passing", "brightgreen"),
+        }
+        runner = CliRunner()
+        result = runner.invoke(cli, ["--output-dir", str(tmp_path)])
+        assert result.exit_code == 0
+        assert "Generating badges" in result.output
+        assert "Generated 2 badges" in result.output
+        mock_gen.assert_called_once_with(tmp_path)
+
+
+def test_main_module_block() -> None:
+    import scripts.generate_badges as gb
+
+    with patch.object(gb, "cli") as mock_cli:
+        with patch.object(gb, "__name__", "__main__"):
+            gb.cli([])
+        mock_cli.assert_called_once_with([])