mcp-github-agent 0.1.0__py3-none-any.whl

tests/test_review_engine.py

@@ -0,0 +1,162 @@
+"""Tests for review_engine.py."""
+from unittest.mock import Mock, patch
+
+import pytest
+
+from src.analyzers.base import Finding
+from src.diff_parser import ChangedFile
+from src.review_engine import (
+    _DEFAULT_MAX_DIFF_BYTES,
+    _MAX_DIFF_BYTES_HARD_CAP,
+    _get_max_diff_bytes,
+    ReviewService,
+)
+
+
+def test_review_filters_analyzer_findings_to_changed_python_lines():
+    analyzer = Mock()
+    analyzer.analyze.return_value = [
+        Finding("warning", "src/app.py", 2, "F401", "unused", source="ruff"),
+        Finding("warning", "src/app.py", 9, "E501", "long", source="ruff"),
+    ]
+    service = ReviewService()
+    service.analyzers = [analyzer]
+
+    with patch("src.review_engine.parse_diff", return_value=[
+        ChangedFile("src/app.py", added_lines={2}),
+        ChangedFile("README.md", added_lines={1}),
+    ]), patch("src.review_engine.legacy_review", return_value=[]):
+        findings = service.review("diff")
+
+    assert [f.rule for f in findings] == ["F401"]
+    analyzer.analyze.assert_called_once_with("src/app.py")
+
+
+def test_review_ignores_analyzer_errors_and_adds_legacy_findings():
+    analyzer = Mock()
+    analyzer.analyze.side_effect = RuntimeError("ruff failed")
+    service = ReviewService()
+    service.analyzers = [analyzer]
+
+    with patch("src.review_engine.parse_diff", return_value=[
+        ChangedFile("src/app.py", added_lines={2}),
+    ]), patch("src.review_engine.legacy_review", return_value=[
+        {
+            "severity": "error",
+            "line": 2,
+            "rule": "no-bare-except",
+            "message": "Bare except clause",
+            "file": "src/app.py",
+        }
+    ]):
+        findings = service.review("diff")
+
+    assert len(findings) == 1
+    assert findings[0].rule == "no-bare-except"
+    assert findings[0].source == "regex"
+
+
+def test_review_service_handles_missing_ruff_analyzer():
+    with patch("src.review_engine.RuffAnalyzer", side_effect=RuntimeError("missing")):
+        service = ReviewService()
+
+    assert service.analyzers == []
+
+
+def test_review_rejects_diff_larger_than_500kb(monkeypatch):
+    monkeypatch.setenv("GITHUB_REVIEW_MAX_DIFF_BYTES", "1024")  # 1KB limit
+    assert _get_max_diff_bytes() == 1024
+
+    service = ReviewService()
+    huge_diff = "x" * 2048  # 2KB
+    findings = service.review(huge_diff)
+    assert len(findings) == 1
+    assert findings[0].rule == "diff-too-large"
+    assert findings[0].severity == "error"
+
+
+def test_review_processes_diff_exactly_at_size_limit(monkeypatch):
+    monkeypatch.setenv("GITHUB_REVIEW_MAX_DIFF_BYTES", str(_DEFAULT_MAX_DIFF_BYTES))
+    service = ReviewService()
+    boundary_diff = "x" * _DEFAULT_MAX_DIFF_BYTES
+
+    with patch("src.review_engine.parse_diff", return_value=[]) as parse, \
+         patch("src.review_engine.legacy_review", return_value=[]) as legacy:
+        findings = service.review(boundary_diff)
+
+    assert findings == []
+    parse.assert_called_once_with(boundary_diff)
+    legacy.assert_called_once_with(boundary_diff)
+
+
+def test_review_rejects_diff_one_byte_over_default_limit(monkeypatch):
+    monkeypatch.delenv("GITHUB_REVIEW_MAX_DIFF_BYTES", raising=False)
+    service = ReviewService()
+    oversized_diff = "x" * (_DEFAULT_MAX_DIFF_BYTES + 1)
+
+    with patch("src.review_engine.parse_diff") as parse, \
+         patch("src.review_engine.legacy_review") as legacy:
+        findings = service.review(oversized_diff)
+
+    assert len(findings) == 1
+    assert findings[0].rule == "diff-too-large"
+    assert findings[0].severity == "error"
+    assert findings[0].source == "review_engine"
+    parse.assert_not_called()
+    legacy.assert_not_called()
+
+
+def test_review_allows_empty_diff():
+    service = ReviewService()
+
+    with patch("src.review_engine.parse_diff", return_value=[]) as parse, \
+         patch("src.review_engine.legacy_review", return_value=[]) as legacy:
+        findings = service.review("")
+
+    assert findings == []
+    parse.assert_called_once_with("")
+    legacy.assert_called_once_with("")
+
+
+def test_review_handles_binary_like_decoded_diff_text(monkeypatch):
+    monkeypatch.setenv("GITHUB_REVIEW_MAX_DIFF_BYTES", "1024")
+    service = ReviewService()
+    binary_like_diff = "diff --git a/blob b/blob\n+\x00\x80\xff"
+
+    with patch("src.review_engine.parse_diff", return_value=[]) as parse, \
+         patch("src.review_engine.legacy_review", return_value=[]) as legacy:
+        findings = service.review(binary_like_diff)
+
+    assert findings == []
+    parse.assert_called_once_with(binary_like_diff)
+    legacy.assert_called_once_with(binary_like_diff)
+
+
+@pytest.mark.xfail(
+    raises=UnicodeEncodeError,
+    reason="ReviewService.review accepts str and currently crashes on unpaired surrogates.",
+)
+def test_review_current_gap_non_utf8_surrogateescape_text():
+    ReviewService().review("\udcff")
+
+
+def test_invalid_max_diff_size_env_falls_back_to_default(monkeypatch):
+    monkeypatch.setenv("GITHUB_REVIEW_MAX_DIFF_BYTES", "abc")
+
+    assert _get_max_diff_bytes() == _DEFAULT_MAX_DIFF_BYTES
+
+
+def test_large_max_diff_size_env_override_is_clamped_to_hard_cap(monkeypatch, caplog):
+    ten_gib = 10 * 1024 * 1024 * 1024
+    monkeypatch.setenv("GITHUB_REVIEW_MAX_DIFF_BYTES", str(ten_gib))
+
+    assert _get_max_diff_bytes() == _MAX_DIFF_BYTES_HARD_CAP
+    assert "exceeds hard cap" in caplog.text
+
+
+def test_review_allows_diff_under_limit():
+    service = ReviewService()
+    with patch("src.review_engine.parse_diff", return_value=[]), \
+         patch("src.review_engine.legacy_review", return_value=[]):
+        findings = service.review("small diff")
+    assert all(f.rule != "diff-too-large" for f in findings)

tests/test_ruff_analyzer.py

@@ -0,0 +1,78 @@
+"""Tests for analyzers/ruff.py."""
+import json
+import subprocess
+from types import SimpleNamespace
+from unittest.mock import patch
+
+from src.analyzers.ruff import RuffAnalyzer
+
+
+def test_ruff_analyzer_skips_non_python_files():
+    with patch("src.analyzers.ruff.subprocess.run") as mock_run:
+        assert RuffAnalyzer().analyze("README.md") == []
+    mock_run.assert_not_called()
+
+
+def test_ruff_analyzer_parses_json_findings():
+    payload = [
+        {
+            "filename": "src/app.py",
+            "location": {"row": 3},
+            "code": "F401",
+            "message": "unused import",
+            "fix": {"message": "Remove import"},
+        },
+        {
+            "filename": "src/app.py",
+            "location": {"row": 5},
+            "code": "E501",
+            "message": "line too long",
+        },
+    ]
+    completed = SimpleNamespace(returncode=1, stdout=json.dumps(payload))
+
+    with patch("src.analyzers.ruff.subprocess.run", return_value=completed) as mock_run:
+        findings = RuffAnalyzer("custom-ruff").analyze("src/app.py")
+
+    assert [f.rule for f in findings] == ["F401", "E501"]
+    assert findings[0].severity == "error"
+    assert findings[0].suggestion == "Remove import"
+    assert findings[1].severity == "warning"
+    mock_run.assert_called_once_with(
+        ["custom-ruff", "check", "--output-format", "json", "src/app.py"],
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+
+
+def test_ruff_analyzer_returns_empty_for_clean_output_and_failures():
+    with patch(
+        "src.analyzers.ruff.subprocess.run",
+        return_value=SimpleNamespace(returncode=0, stdout=""),
+    ):
+        assert RuffAnalyzer().analyze("src/app.py") == []
+
+    with patch(
+        "src.analyzers.ruff.subprocess.run",
+        return_value=SimpleNamespace(returncode=2, stdout="[]"),
+    ):
+        assert RuffAnalyzer().analyze("src/app.py") == []
+
+    with patch(
+        "src.analyzers.ruff.subprocess.run",
+        return_value=SimpleNamespace(returncode=1, stdout="not-json"),
+    ):
+        assert RuffAnalyzer().analyze("src/app.py") == []
+
+    with patch(
+        "src.analyzers.ruff.subprocess.run",
+        side_effect=FileNotFoundError,
+    ):
+        assert RuffAnalyzer().analyze("src/app.py") == []
+
+    with patch(
+        "src.analyzers.ruff.subprocess.run",
+        side_effect=subprocess.TimeoutExpired("ruff", 30),
+    ):
+        assert RuffAnalyzer().analyze("src/app.py") == []

tests/test_tools.py

@@ -0,0 +1,326 @@
+"""Tests for GitHub MCP tools"""
+import unittest
+from unittest.mock import patch, Mock
+from src.analyzers.base import Finding
+from src.policy import PolicyDecision
+from src.tools import (
+    search_code,
+    list_issues,
+    get_pr_diff,
+    review_pr_diff,
+    comment_pr_review,
+    create_issue,
+    create_pr,
+)
+from src.review import review_diff
+
+
+class TestTools(unittest.TestCase):
+
+    def _allow_policy(self):
+        policy = Mock()
+        policy.check_repo.return_value = PolicyDecision(
+            "allow", "repo allowed", "repo_allowlist:owner/*"
+        )
+        policy.check_branch_for_pr.return_value = PolicyDecision(
+            "allow", "branch allowed", "branch_unprotected"
+        )
+        return policy
+
+    def _audit(self):
+        audit = Mock()
+        audit.log.return_value = None
+        return audit
+
+    @patch('src.tools.GitHubClient')
+    def test_search_code(self, mock_client_class):
+        """Test search_code tool with mocked httpx response"""
+        # Setup mock
+        mock_client = Mock()
+        mock_client_class.return_value = mock_client
+        mock_client.search_code.return_value = {
+            "items": [
+                {
+                    'path': 'src/main.py',
+                    'repo': 'owner/test-repo',
+                    'url': 'https://github.com/owner/test-repo/blob/main/src/main.py'
+                }
+            ]
+        }
+
+        # Call function
+        result = search_code("def main", "owner/test-repo")
+
+        # Verify
+        self.assertIn("Found 1 results", result)
+        self.assertIn("src/main.py in owner/test-repo", result)
+        self.assertIn("https://github.com/owner/test-repo", result)
+        mock_client.search_code.assert_called_once_with("def main", "owner/test-repo")
+
+    def test_review_diff(self):
+        """Test review_diff catches print statement"""
+        diff_text = """diff --git a/src/test.py b/src/test.py
+index 1234567..abcdefg 100644
+--- a/src/test.py
++++ b/src/test.py
+@@ -1,3 +1,4 @@
+ def hello():
++    print("Debug message")
+     return "world"
+"""
+
+        issues = review_diff(diff_text)
+
+        # Should find the print statement
+        self.assertEqual(len(issues), 1)
+        self.assertEqual(issues[0]['severity'], 'warning')
+        self.assertEqual(issues[0]['rule'], 'no-print')
+        self.assertIn('Print statement found', issues[0]['message'])
+
+
+    def test_search_empty_results(self):
+        """Test search_code returns proper message for no results"""
+        from unittest.mock import patch, Mock
+        with patch('src.tools.GitHubClient') as mock_cls:
+            mock_cls.return_value.search_code.return_value = {"items": []}
+            result = search_code("nonexistent", "owner/repo")
+            self.assertIn("No results", result)
+
+    def test_search_error(self):
+        """Test search_code handles API errors gracefully"""
+        from unittest.mock import patch, Mock
+        with patch('src.tools.GitHubClient') as mock_cls:
+            mock_cls.return_value.search_code.return_value = {"error": "API rate limit exceeded"}
+            result = search_code("test", "owner/repo")
+            self.assertIn("Error", result)
+            self.assertIn("rate limit", result)
+
+    def test_list_issues_success(self):
+        with patch('src.tools.GitHubClient') as mock_cls:
+            mock_cls.return_value.list_issues.return_value = [
+                {"number": 1, "title": "Bug", "html_url": "https://example/1"}
+            ]
+            result = list_issues("owner/repo", "closed")
+            self.assertIn("Issues in owner/repo (closed)", result)
+            self.assertIn("#1: Bug", result)
+            mock_cls.return_value.list_issues.assert_called_once_with("owner/repo", "closed")
+
+    def test_list_issues_empty_and_error(self):
+        with patch('src.tools.GitHubClient') as mock_cls:
+            mock_cls.return_value.list_issues.return_value = []
+            self.assertIn("No open issues", list_issues("owner/repo"))
+
+            mock_cls.return_value.list_issues.return_value = {"error": "bad credentials"}
+            self.assertEqual(list_issues("owner/repo"), "Error: bad credentials")
+
+    def test_get_pr_diff_success_and_error(self):
+        with patch('src.tools.GitHubClient') as mock_cls:
+            mock_cls.return_value.get_pr_diff.return_value = {"diff": "+change"}
+            self.assertIn("PR #7 diff:\n\n+change", get_pr_diff("owner/repo", 7))
+
+            mock_cls.return_value.get_pr_diff.return_value = {"error": "not found"}
+            self.assertEqual(get_pr_diff("owner/repo", 7), "Error: not found")
+
+    def test_review_pr_diff_formats_findings(self):
+        finding = Finding(
+            severity="error", file="src/app.py", line=3, rule="F401",
+            message="unused import", source="ruff"
+        )
+        with patch('src.tools.GitHubClient') as mock_cls, \
+                patch('src.tools.ReviewService') as mock_review:
+            mock_cls.return_value.get_pr_diff.return_value = {"diff": "diff"}
+            mock_review.return_value.review.return_value = [finding]
+            result = review_pr_diff("owner/repo", 8)
+            self.assertIn("Code review for PR #8 (1 issues)", result)
+            self.assertIn("src/app.py:3", result)
+            self.assertIn("[F401/ruff]", result)
+
+    def test_review_pr_diff_handles_error_and_no_findings(self):
+        with patch('src.tools.GitHubClient') as mock_cls, \
+                patch('src.tools.ReviewService') as mock_review:
+            mock_cls.return_value.get_pr_diff.return_value = {"error": "rate limited"}
+            self.assertEqual(review_pr_diff("owner/repo", 8), "Error: rate limited")
+
+            mock_cls.return_value.get_pr_diff.return_value = {"diff": "diff"}
+            mock_review.return_value.review.side_effect = RuntimeError("ruff crashed")
+            self.assertIn("looks good", review_pr_diff("owner/repo", 8))
+
+    def test_review_pr_diff_returns_diff_too_large_finding(self):
+        with patch.dict(
+            "os.environ",
+            {"GITHUB_REVIEW_MAX_DIFF_BYTES": "1024"},
+            clear=False,
+        ), patch('src.tools.GitHubClient') as mock_cls:
+            mock_cls.return_value.get_pr_diff.return_value = {"diff": "x" * 1025}
+
+            result = review_pr_diff("owner/repo", 8)
+
+        self.assertIn("Code review for PR #8 (1 issues)", result)
+        self.assertIn("Diff too large (1 KB, limit 1 KB)", result)
+        self.assertIn("[diff-too-large/review_engine]", result)
+        self.assertIn(":0", result)
+
+    def test_comment_pr_review_posts_top_findings(self):
+        findings = [
+            Finding("warning", f"src/{i}.py", i, "R", f"message {i}", source="regex")
+            for i in range(1, 12)
+        ]
+        with patch('src.tools.GitHubClient') as mock_cls, \
+                patch('src.tools.ReviewService') as mock_review:
+            client = mock_cls.return_value
+            client.get_pr_diff.return_value = {"diff": "diff"}
+            client.create_review_comment.side_effect = [{"id": i} for i in range(10)]
+            mock_review.return_value.review.return_value = findings
+
+            result = comment_pr_review("owner/repo", 9)
+
+            self.assertIn("Posted 10 review comments", result)
+            self.assertIn("11 total issues", result)
+            self.assertEqual(client.create_review_comment.call_count, 10)
+
+    def test_comment_pr_review_counts_failed_posts_and_empty_review(self):
+        finding = Finding("warning", "src/app.py", 5, "R", "message", source="regex")
+        with patch('src.tools.GitHubClient') as mock_cls, \
+                patch('src.tools.ReviewService') as mock_review:
+            client = mock_cls.return_value
+            client.get_pr_diff.return_value = {"error": "missing diff"}
+            self.assertEqual(comment_pr_review("owner/repo", 9), "Error: missing diff")
+
+            client.get_pr_diff.return_value = {"diff": "diff"}
+            mock_review.return_value.review.return_value = []
+            self.assertIn("looks good", comment_pr_review("owner/repo", 9))
+
+            mock_review.return_value.review.return_value = [finding]
+            client.create_review_comment.return_value = {"error": "validation failed"}
+            self.assertIn("Posted 0 review comments", comment_pr_review("owner/repo", 9))
+
+    def test_create_issue_success(self):
+        """Test create_issue tool formats success response"""
+        with patch('src.tools.GitHubClient') as mock_cls, \
+                patch('src.tools._get_policy', return_value=self._allow_policy()), \
+                patch('src.tools._get_audit', return_value=self._audit()):
+            mock_cls.return_value.create_issue.return_value = {
+                "number": 42, "title": "Test Issue", "html_url": "https://github.com/owner/repo/issues/42"
+            }
+            result = create_issue("owner/repo", "Test Issue", "Body text")
+            self.assertIn("42", result)
+            self.assertIn("Test Issue", result)
+
+    def test_create_issue_error(self):
+        """Test create_issue handles errors"""
+        with patch('src.tools.GitHubClient') as mock_cls, \
+                patch('src.tools._get_policy', return_value=self._allow_policy()), \
+                patch('src.tools._get_audit', return_value=self._audit()):
+            mock_cls.return_value.create_issue.return_value = {"error": "Not authorized"}
+            result = create_issue("owner/repo", "Test", "Body")
+            self.assertIn("Error", result)
+
+    def test_create_issue_policy_denied_and_dry_run(self):
+        denied_policy = self._allow_policy()
+        denied_policy.check_repo.return_value = PolicyDecision(
+            "deny", "repo blocked", "repo_allowlist:deny_unlisted"
+        )
+        audit = self._audit()
+        with patch('src.tools._get_policy', return_value=denied_policy), \
+                patch('src.tools._get_audit', return_value=audit), \
+                patch('src.tools.GitHubClient') as mock_cls:
+            result = create_issue("owner/repo", "Title", "Body")
+            self.assertIn("Policy Denied: repo blocked", result)
+            mock_cls.assert_not_called()
+            audit.log.assert_called_once()
+
+        with patch('src.tools._get_policy', return_value=self._allow_policy()), \
+                patch('src.tools._get_audit', return_value=self._audit()), \
+                patch('src.tools.GitHubClient') as mock_cls:
+            result = create_issue("owner/repo", "Title", "x" * 130, dry_run=True)
+            self.assertIn("[DRY RUN] Would create issue", result)
+            self.assertIn("...", result)
+            mock_cls.assert_not_called()
+
+    def test_create_pr_success_and_error(self):
+        with patch('src.tools.GitHubClient') as mock_cls, \
+                patch('src.tools._get_policy', return_value=self._allow_policy()), \
+                patch('src.tools._get_audit', return_value=self._audit()):
+            mock_cls.return_value.create_pr.return_value = {
+                "number": 5, "title": "Fix", "html_url": "https://example/pr/5"
+            }
+            result = create_pr("owner/repo", "Fix", "Body", "feature", "develop")
+            self.assertIn("PR created: #5: Fix", result)
+            mock_cls.return_value.create_pr.assert_called_once_with(
+                "owner/repo", "Fix", "Body", "feature", "develop"
+            )
+
+            mock_cls.return_value.create_pr.return_value = {"error": "branch missing"}
+            self.assertEqual(
+                create_pr("owner/repo", "Fix", "Body", "feature", "develop"),
+                "Error: branch missing",
+            )
+
+    def test_create_pr_policy_denials_and_dry_run(self):
+        repo_denied = self._allow_policy()
+        repo_denied.check_repo.return_value = PolicyDecision(
+            "deny", "repo blocked", "repo_allowlist:deny_unlisted"
+        )
+        branch_denied = self._allow_policy()
+        branch_denied.check_branch_for_pr.return_value = PolicyDecision(
+            "deny", "main blocked", "protected_branch:main"
+        )
+
+        with patch('src.tools._get_policy', return_value=repo_denied), \
+                patch('src.tools._get_audit', return_value=self._audit()), \
+                patch('src.tools.GitHubClient') as mock_cls:
+            self.assertIn(
+                "Policy Denied: repo blocked",
+                create_pr("owner/repo", "Fix", "Body", "feature", "main"),
+            )
+            mock_cls.assert_not_called()
+
+        with patch('src.tools._get_policy', return_value=branch_denied), \
+                patch('src.tools._get_audit', return_value=self._audit()), \
+                patch('src.tools.GitHubClient') as mock_cls:
+            self.assertIn(
+                "Policy Denied: main blocked",
+                create_pr("owner/repo", "Fix", "Body", "feature", "main"),
+            )
+            mock_cls.assert_not_called()
+
+        with patch('src.tools._get_policy', return_value=self._allow_policy()), \
+                patch('src.tools._get_audit', return_value=self._audit()), \
+                patch('src.tools.GitHubClient') as mock_cls:
+            result = create_pr(
+                "owner/repo", "Fix", "Body", "feature", "develop", dry_run=True
+            )
+            self.assertIn("[DRY RUN] Would create PR", result)
+            self.assertIn("Head:   feature", result)
+            mock_cls.assert_not_called()
+
+    def test_review_diff_multiple_issues(self):
+        """Test review_diff catches multiple rule violations"""
+        diff = """diff --git a/src/app.py b/src/app.py
+@@ -1,8 +1,12 @@
+ def process():
++    password = "secret123"
+     data = get_data()
++    print(data)
++    # TODO: fix this later
+     return data
++except:
++    pass
+"""
+        issues = review_diff(diff)
+        self.assertGreaterEqual(len(issues), 3)
+        rules = [i['rule'] for i in issues]
+        self.assertIn('no-print', rules)
+        self.assertIn('no-hardcoded-secrets', rules)
+        self.assertIn('no-todo-comments', rules)
+
+    def test_review_diff_clean(self):
+        """Test review_diff returns empty for clean code"""
+        diff = """diff --git a/src/app.py b/src/app.py
+@@ -1,3 +1,4 @@
+ def hello():
++    logger.info("Starting")
+     return True
+"""
+        issues = review_diff(diff)
+        self.assertEqual(len(issues), 0)