jleechanorg-pr-automation 0.1.1__py3-none-any.whl → 0.2.45__py3-none-any.whl

jleechanorg_pr_automation/tests/test_pr_monitor_eligibility.py

@@ -0,0 +1,354 @@
+import unittest
+
+from _pytest.capture import CaptureFixture
+from _pytest.monkeypatch import MonkeyPatch
+from automation.jleechanorg_pr_automation import jleechanorg_pr_monitor as mon
+
+FAILED_PR_NUMBER = 2
+EXPECTED_ACTIONABLE_COUNT = 2
+
+
+def codex_marker(monitor: mon.JleechanorgPRMonitor, token: str) -> str:
+    return f"{monitor.CODEX_COMMIT_MARKER_PREFIX}{token}{monitor.CODEX_COMMIT_MARKER_SUFFIX}"
+
+
+def test_list_actionable_prs_conflicts_and_failing(monkeypatch: MonkeyPatch, capsys: CaptureFixture[str]) -> None:
+    monitor = mon.JleechanorgPRMonitor(automation_username="test-automation-user")
+
+    sample_prs = [
+        {"repository": "repo/a", "number": 1, "title": "conflict", "mergeable": "CONFLICTING"},
+        {"repository": "repo/b", "number": 2, "title": "failing", "mergeable": "MERGEABLE"},
+        {"repository": "repo/c", "number": 3, "title": "passing", "mergeable": "MERGEABLE"},
+    ]
+
+    monkeypatch.setattr(monitor, "discover_open_prs", lambda: sample_prs)
+
+    def fake_has_failing_checks(repo: str, pr_number: int) -> bool:  # noqa: ARG001
+        return pr_number == FAILED_PR_NUMBER
+
+    monkeypatch.setattr(mon, "has_failing_checks", fake_has_failing_checks)
+
+    actionable = monitor.list_actionable_prs(max_prs=10)
+
+    assert len(actionable) == EXPECTED_ACTIONABLE_COUNT
+    assert {pr["number"] for pr in actionable} == {1, FAILED_PR_NUMBER}
+
+    captured = capsys.readouterr().out
+    assert "Eligible for fixpr: 2" in captured
+
+
+class TestBotCommentDetection(unittest.TestCase):
+    """Validate detection of new GitHub bot comments since last Codex automation comment."""
+
+    def setUp(self) -> None:
+        self.monitor = mon.JleechanorgPRMonitor(automation_username="test-automation-user")
+
+    def test_identifies_new_github_actions_bot_comment(self) -> None:
+        """Should detect new comment from github-actions[bot] after Codex comment."""
+        comments = [
+            {
+                "author": {"login": "jleechan"},
+                "body": f"@codex fix this {codex_marker(self.monitor, 'abc123')}",
+                "createdAt": "2024-01-01T10:00:00Z",
+            },
+            {
+                "author": {"login": "github-actions[bot]"},
+                "body": "CI failed: test_something assertion error",
+                "createdAt": "2024-01-01T11:00:00Z",
+            },
+        ]
+
+        assert self.monitor._has_new_bot_comments_since_codex(comments)  # noqa: SLF001
+
+    def test_identifies_new_dependabot_comment(self) -> None:
+        """Should detect new comment from dependabot[bot] after Codex comment."""
+        comments = [
+            {
+                "author": {"login": "jleechan"},
+                "body": f"Fix issue {codex_marker(self.monitor, 'def456')}",
+                "createdAt": "2024-01-01T10:00:00Z",
+            },
+            {
+                "author": {"login": "dependabot[bot]"},
+                "body": "Security vulnerability detected",
+                "createdAt": "2024-01-01T11:00:00Z",
+            },
+        ]
+
+        assert self.monitor._has_new_bot_comments_since_codex(comments)  # noqa: SLF001
+
+    def test_no_detection_when_bot_comment_before_codex(self) -> None:
+        """Should NOT detect bot comments that came BEFORE Codex comment."""
+        comments = [
+            {
+                "author": {"login": "github-actions[bot]"},
+                "body": "CI failed",
+                "createdAt": "2024-01-01T09:00:00Z",
+            },
+            {
+                "author": {"login": "jleechan"},
+                "body": f"@codex fix {codex_marker(self.monitor, 'abc123')}",
+                "createdAt": "2024-01-01T10:00:00Z",
+            },
+        ]
+
+        assert not self.monitor._has_new_bot_comments_since_codex(comments)  # noqa: SLF001
+
+    def test_identifies_bot_comment_without_prior_codex_comment(self) -> None:
+        """Should treat any bot comment as new when no Codex automation comment exists."""
+        comments = [
+            {
+                "author": {"login": "github-actions[bot]"},
+                "body": "CI failed",
+                "createdAt": "2024-01-01T10:00:00Z",
+            },
+            {
+                "author": {"login": "jleechan"},
+                "body": "Regular comment without marker",
+                "createdAt": "2024-01-01T11:00:00Z",
+            },
+        ]
+
+        assert self.monitor._has_new_bot_comments_since_codex(comments)  # noqa: SLF001
+
+    def test_excludes_codex_bot_comments(self) -> None:
+        """Should NOT count codex[bot] as a new bot comment to process."""
+        comments = [
+            {
+                "author": {"login": "jleechan"},
+                "body": f"@codex fix {codex_marker(self.monitor, 'abc123')}",
+                "createdAt": "2024-01-01T10:00:00Z",
+            },
+            {
+                "author": {"login": "codex[bot]"},
+                "body": "Codex summary: fixed the issue",
+                "createdAt": "2024-01-01T11:00:00Z",
+            },
+        ]
+
+        assert not self.monitor._has_new_bot_comments_since_codex(comments)  # noqa: SLF001
+
+    def test_identifies_coderabbitai_bot_comments(self) -> None:
+        """Should count coderabbitai[bot] as a new bot comment to process."""
+        comments = [
+            {
+                "author": {"login": "jleechan"},
+                "body": f"@codex fix {codex_marker(self.monitor, 'abc123')}",
+                "createdAt": "2024-01-01T10:00:00Z",
+            },
+            {
+                "author": {"login": "coderabbitai[bot]"},
+                "body": "Code review completed",
+                "createdAt": "2024-01-01T11:00:00Z",
+            },
+        ]
+
+        assert self.monitor._has_new_bot_comments_since_codex(comments)  # noqa: SLF001
+
+    def test_excludes_copilot_bot_comments(self) -> None:
+        """Should NOT count copilot[bot] as a new bot comment to process."""
+        comments = [
+            {
+                "author": {"login": "jleechan"},
+                "body": f"@codex fix {codex_marker(self.monitor, 'abc123')}",
+                "createdAt": "2024-01-01T10:00:00Z",
+            },
+            {
+                "author": {"login": "copilot[bot]"},
+                "body": "Copilot suggestion",
+                "createdAt": "2024-01-01T11:00:00Z",
+            },
+        ]
+
+        assert not self.monitor._has_new_bot_comments_since_codex(comments)  # noqa: SLF001
+
+    def test_ignores_human_comments_after_codex(self) -> None:
+        """Human comments after Codex should NOT trigger new bot detection."""
+        comments = [
+            {
+                "author": {"login": "jleechan"},
+                "body": f"@codex fix {codex_marker(self.monitor, 'abc123')}",
+                "createdAt": "2024-01-01T10:00:00Z",
+            },
+            {
+                "author": {"login": "reviewer"},
+                "body": "LGTM",
+                "createdAt": "2024-01-01T11:00:00Z",
+            },
+        ]
+
+        assert not self.monitor._has_new_bot_comments_since_codex(comments)  # noqa: SLF001
+
+    def test_uses_latest_codex_comment_time(self) -> None:
+        """Should use the timestamp of the MOST RECENT Codex comment."""
+        comments = [
+            {
+                "author": {"login": "jleechan"},
+                "body": f"Fix 1 {codex_marker(self.monitor, 'abc123')}",
+                "createdAt": "2024-01-01T10:00:00Z",
+            },
+            {
+                "author": {"login": "github-actions[bot]"},
+                "body": "CI failed",
+                "createdAt": "2024-01-01T11:00:00Z",
+            },
+            {
+                "author": {"login": "jleechan"},
+                "body": f"Fix 2 {codex_marker(self.monitor, 'def456')}",
+                "createdAt": "2024-01-01T12:00:00Z",
+            },
+        ]
+
+        # Bot comment at 11:00 is BEFORE latest Codex comment at 12:00
+        assert not self.monitor._has_new_bot_comments_since_codex(comments)  # noqa: SLF001
+
+    def test_identifies_bot_comment_after_latest_codex(self) -> None:
+        """Should detect bot comment that comes after the latest Codex comment."""
+        comments = [
+            {
+                "author": {"login": "jleechan"},
+                "body": f"Fix 1 {codex_marker(self.monitor, 'abc123')}",
+                "createdAt": "2024-01-01T10:00:00Z",
+            },
+            {
+                "author": {"login": "jleechan"},
+                "body": f"Fix 2 {codex_marker(self.monitor, 'def456')}",
+                "createdAt": "2024-01-01T11:00:00Z",
+            },
+            {
+                "author": {"login": "github-actions[bot]"},
+                "body": "CI still failing",
+                "createdAt": "2024-01-01T12:00:00Z",
+            },
+        ]
+
+        assert self.monitor._has_new_bot_comments_since_codex(comments)  # noqa: SLF001
+
+    def test_handles_empty_comments_list(self) -> None:
+        """Should handle empty comments list gracefully."""
+        assert not self.monitor._has_new_bot_comments_since_codex([])  # noqa: SLF001
+
+    def test_handles_missing_author(self) -> None:
+        """Should handle comments with missing author field."""
+        comments = [
+            {
+                "author": {"login": "jleechan"},
+                "body": f"Fix {codex_marker(self.monitor, 'abc123')}",
+                "createdAt": "2024-01-01T10:00:00Z",
+            },
+            {
+                "body": "Comment with no author",
+                "createdAt": "2024-01-01T11:00:00Z",
+            },
+        ]
+
+        # Should not crash and should return False (no valid bot comment)
+        assert not self.monitor._has_new_bot_comments_since_codex(comments)  # noqa: SLF001
+
+
+class TestIsGithubBotComment(unittest.TestCase):
+    """Validate _is_github_bot_comment method."""
+
+    def setUp(self) -> None:
+        self.monitor = mon.JleechanorgPRMonitor(automation_username="test-automation-user")
+
+    def test_identifies_github_actions_bot(self) -> None:
+        comment = {"author": {"login": "github-actions[bot]"}}
+        assert self.monitor._is_github_bot_comment(comment)  # noqa: SLF001
+
+    def test_identifies_dependabot(self) -> None:
+        comment = {"author": {"login": "dependabot[bot]"}}
+        assert self.monitor._is_github_bot_comment(comment)  # noqa: SLF001
+
+    def test_identifies_renovate_bot(self) -> None:
+        comment = {"author": {"login": "renovate[bot]"}}
+        assert self.monitor._is_github_bot_comment(comment)  # noqa: SLF001
+
+    def test_identifies_coderabbitai_without_bot_suffix(self) -> None:
+        comment = {"author": {"login": "coderabbitai"}}
+        assert self.monitor._is_github_bot_comment(comment)  # noqa: SLF001
+
+    def test_identifies_copilot_swe_agent_without_bot_suffix(self) -> None:
+        comment = {"author": {"login": "copilot-swe-agent"}}
+        assert self.monitor._is_github_bot_comment(comment)  # noqa: SLF001
+
+    def test_identifies_github_actions_without_bot_suffix(self) -> None:
+        comment = {"author": {"login": "github-actions"}}
+        assert self.monitor._is_github_bot_comment(comment)  # noqa: SLF001
+
+    def test_excludes_codex_bot(self) -> None:
+        comment = {"author": {"login": "codex[bot]"}}
+        assert not self.monitor._is_github_bot_comment(comment)  # noqa: SLF001
+
+    def test_identifies_coderabbitai_bot_with_suffix(self) -> None:
+        comment = {"author": {"login": "coderabbitai[bot]"}}
+        assert self.monitor._is_github_bot_comment(comment)  # noqa: SLF001
+
+    def test_excludes_copilot_bot(self) -> None:
+        comment = {"author": {"login": "copilot[bot]"}}
+        assert not self.monitor._is_github_bot_comment(comment)  # noqa: SLF001
+
+    def test_excludes_cursor_bot(self) -> None:
+        comment = {"author": {"login": "cursor[bot]"}}
+        assert not self.monitor._is_github_bot_comment(comment)  # noqa: SLF001
+
+    def test_excludes_human_user(self) -> None:
+        comment = {"author": {"login": "jleechan"}}
+        assert not self.monitor._is_github_bot_comment(comment)  # noqa: SLF001
+
+    def test_handles_user_field_fallback(self) -> None:
+        comment = {"user": {"login": "github-actions[bot]"}}
+        assert self.monitor._is_github_bot_comment(comment)  # noqa: SLF001
+
+    def test_handles_empty_author(self) -> None:
+        comment = {"author": {}}
+        assert not self.monitor._is_github_bot_comment(comment)  # noqa: SLF001
+
+    def test_handles_missing_author(self) -> None:
+        comment = {"body": "no author"}
+        assert not self.monitor._is_github_bot_comment(comment)  # noqa: SLF001
+
+
+class TestGetLastCodexAutomationCommentTime(unittest.TestCase):
+    """Validate _get_last_codex_automation_comment_time method."""
+
+    def setUp(self) -> None:
+        self.monitor = mon.JleechanorgPRMonitor(automation_username="test-automation-user")
+
+    def test_returns_latest_codex_comment_time(self) -> None:
+        comments = [
+            {
+                "body": f"First {self.monitor.CODEX_COMMIT_MARKER_PREFIX}abc{self.monitor.CODEX_COMMIT_MARKER_SUFFIX}",
+                "createdAt": "2024-01-01T10:00:00Z",
+            },
+            {
+                "body": f"Second {self.monitor.CODEX_COMMIT_MARKER_PREFIX}def{self.monitor.CODEX_COMMIT_MARKER_SUFFIX}",
+                "createdAt": "2024-01-01T12:00:00Z",
+            },
+        ]
+
+        result = self.monitor._get_last_codex_automation_comment_time(comments)  # noqa: SLF001
+        assert result == "2024-01-01T12:00:00Z"
+
+    def test_returns_none_when_no_codex_comments(self) -> None:
+        comments = [
+            {"body": "Regular comment", "createdAt": "2024-01-01T10:00:00Z"},
+        ]
+
+        result = self.monitor._get_last_codex_automation_comment_time(comments)  # noqa: SLF001
+        assert result is None
+
+    def test_returns_none_for_empty_list(self) -> None:
+        result = self.monitor._get_last_codex_automation_comment_time([])  # noqa: SLF001
+        assert result is None
+
+    def test_uses_updated_at_fallback(self) -> None:
+        comments = [
+            {
+                "body": f"Update {self.monitor.CODEX_COMMIT_MARKER_PREFIX}xyz{self.monitor.CODEX_COMMIT_MARKER_SUFFIX}",
+                "updatedAt": "2024-01-01T15:00:00Z",
+            },
+        ]
+
+        result = self.monitor._get_last_codex_automation_comment_time(comments)  # noqa: SLF001
+        assert result == "2024-01-01T15:00:00Z"

jleechanorg_pr_automation/tests/test_pr_targeting.py

@@ -14,7 +14,7 @@ class TestPRTargeting(unittest.TestCase):
 
     def test_extract_commit_marker(self):
         """Commit markers can be parsed from Codex comments"""
-        monitor = JleechanorgPRMonitor()
+        monitor = JleechanorgPRMonitor(automation_username="test-automation-user")
         intro_line = build_comment_intro(
             assistant_mentions=monitor.assistant_mentions
         )
@@ -25,6 +25,18 @@ class TestPRTargeting(unittest.TestCase):
         marker = monitor._extract_commit_marker(test_comment)
         self.assertEqual(marker, "abc123")
 
+    def test_fix_comment_marker_detected_for_commit(self):
+        """Fix-comment markers should be detected for commit gating."""
+        monitor = JleechanorgPRMonitor(automation_username="test-automation-user")
+        test_comment = (
+            "Queued\n"
+            f"{monitor.FIX_COMMENT_MARKER_PREFIX}abc123"
+            f"{monitor.FIX_COMMENT_MARKER_SUFFIX}"
+        )
+
+        marker = monitor._extract_fix_comment_marker(test_comment)
+        self.assertEqual(marker, "abc123")
+
     def test_intro_prose_avoids_duplicate_mentions(self):
         """Review assistants should not retain '@' prefixes in prose text."""
 
@@ -43,7 +55,7 @@ class TestPRTargeting(unittest.TestCase):
 
     def test_detect_pending_codex_commit(self):
         """Codex bot summary comments referencing head commit trigger pending detection."""
-        monitor = JleechanorgPRMonitor()
+        monitor = JleechanorgPRMonitor(automation_username="test-automation-user")
         head_sha = "abcdef1234567890"
         comments = [
             {
@@ -56,7 +68,7 @@ class TestPRTargeting(unittest.TestCase):
 
     def test_pending_codex_commit_detects_short_sha_references(self):
         """Cursor Bugbot short SHA references should still count as pending commits."""
-        monitor = JleechanorgPRMonitor()
+        monitor = JleechanorgPRMonitor(automation_username="test-automation-user")
         full_head_sha = "c279655d00dfcab5ac1a2fd9b0f6205ce5cbba12"
         comments = [
             {
@@ -69,7 +81,7 @@ class TestPRTargeting(unittest.TestCase):
 
     def test_pending_codex_commit_ignores_short_head_sha(self):
         """Short head SHAs should not match longer Codex summary hashes."""
-        monitor = JleechanorgPRMonitor()
+        monitor = JleechanorgPRMonitor(automation_username="test-automation-user")
         short_head_sha = "c279655"
         comments = [
             {
@@ -82,7 +94,7 @@ class TestPRTargeting(unittest.TestCase):
 
     def test_pending_codex_commit_requires_codex_author(self):
         """Pending detection ignores non-Codex authors even if commit appears in comment."""
-        monitor = JleechanorgPRMonitor()
+        monitor = JleechanorgPRMonitor(automation_username="test-automation-user")
         head_sha = "abcdef1234567890"
         comments = [
             {
@@ -95,7 +107,7 @@ class TestPRTargeting(unittest.TestCase):
 
     def test_codex_comment_includes_detailed_execution_flow(self):
         """Automation comment should summarize the enforced execution flow with numbered steps."""
-        monitor = JleechanorgPRMonitor()
+        monitor = JleechanorgPRMonitor(automation_username="test-automation-user")
         pr_data = {
             "title": "Improve automation summary",
             "author": {"login": "developer"},
@@ -113,6 +125,89 @@ class TestPRTargeting(unittest.TestCase):
         self.assertIn("1. Review every outstanding PR comment", comment_body)
         self.assertIn("5. Perform a final self-review", comment_body)
 
+    def test_fix_comment_queued_body_excludes_marker(self):
+        """Queued fix-comment notices should not include commit markers."""
+        monitor = JleechanorgPRMonitor(automation_username="test-automation-user")
+        pr_data = {
+            "title": "Queued Fix Comment",
+            "author": {"login": "developer"},
+            "headRefName": "feature/queued",
+        }
+        head_sha = "abc123def456"
+
+        comment_body = monitor._build_fix_comment_queued_body(
+            "org/repo",
+            42,
+            pr_data,
+            head_sha,
+        )
+
+        self.assertNotIn(monitor.FIX_COMMENT_MARKER_PREFIX, comment_body)
+        # Queued notices should use the dedicated run marker (not the completion commit marker).
+        self.assertIn(monitor.FIX_COMMENT_RUN_MARKER_PREFIX, comment_body)
+        self.assertIn(head_sha, comment_body)
+
+    def test_fix_comment_review_body_includes_marker(self):
+        """Review requests should include the fix-comment commit marker."""
+        monitor = JleechanorgPRMonitor(automation_username="test-automation-user")
+        pr_data = {
+            "title": "Review Fix Comment",
+            "author": {"login": "developer"},
+            "headRefName": "feature/review",
+        }
+        head_sha = "deadbeef1234"
+
+        comment_body = monitor._build_fix_comment_review_body(
+            "org/repo",
+            42,
+            pr_data,
+            head_sha,
+        )
+
+        self.assertIn(monitor.FIX_COMMENT_MARKER_PREFIX, comment_body)
+        self.assertIn(monitor.FIX_COMMENT_MARKER_SUFFIX, comment_body)
+
+    def test_fix_comment_prompt_requires_threaded_replies(self):
+        """Fix-comment prompts should require threaded replies via the GitHub API."""
+        monitor = JleechanorgPRMonitor(automation_username="test-automation-user")
+        pr_data = {
+            "title": "Threaded Replies",
+            "author": {"login": "developer"},
+            "headRefName": "feature/threaded",
+        }
+
+        prompt = monitor._build_fix_comment_prompt_body(
+            "org/repo",
+            42,
+            pr_data,
+            "abc123",
+            agent_cli="gemini",
+        ).lower()
+
+        # Verify prompt includes threading guidance
+        self.assertIn("thread", prompt)
+        self.assertIn("gh api", prompt)
+        self.assertIn("review comments", prompt)
+        self.assertIn("issue comments", prompt)
+        # After fix for comment #2669657213, prompt clarifies:
+        # - Inline review comments use: /pulls/{pr_number}/comments/{comment_id}/replies
+        # - Issue comments don't support threading (top-level comments only)
+        self.assertIn("pulls/42/comments", prompt)  # Updated to match actual PR number in prompt
+        self.assertIn("reply individually to each comment", prompt)  # Issue comments clarification
+
+    def test_fix_comment_marker_ignores_queued_comment(self):
+        """Queued notices with markers should not satisfy the fix-comment completion check."""
+        monitor = JleechanorgPRMonitor(automation_username="test-automation-user")
+        head_sha = "feedface1234"
+        comment_body = (
+            "[AI automation] Fix-comment run queued for this PR. "
+            "A review request will follow after updates are pushed.\n\n"
+            f"{monitor.FIX_COMMENT_MARKER_PREFIX}{head_sha}{monitor.FIX_COMMENT_MARKER_SUFFIX}"
+        )
+        comments = [{"body": comment_body}]
+
+        self.assertFalse(monitor._has_fix_comment_comment_for_commit(comments, head_sha))
+
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

jleechanorg_pr_automation/tests/test_version_consistency.py

@@ -0,0 +1,51 @@
+import pytest
+import re
+from pathlib import Path
+from typing import Optional
+
+import jleechanorg_pr_automation
+
+_PROJECT_SECTION_RE = re.compile(r"^\s*\[project\]\s*$")
+_SECTION_RE = re.compile(r"^\s*\[[^\]]+\]\s*$")
+_VERSION_RE = re.compile(r'^\s*version\s*=\s*"([^"]+)"\s*$')
+
+
+def _version_from_pyproject(pyproject_path: Path) -> Optional[str]:
+    if not pyproject_path.exists():
+        return None
+
+    in_project_section = False
+    for line in pyproject_path.read_text(encoding="utf-8").splitlines():
+        if _PROJECT_SECTION_RE.match(line):
+            in_project_section = True
+            continue
+        if in_project_section and _SECTION_RE.match(line):
+            in_project_section = False
+            continue
+        if not in_project_section:
+            continue
+
+        match = _VERSION_RE.match(line)
+        if match:
+            version = match.group(1).strip()
+            return version or None
+
+    return None
+
+
+def test_package_version_matches_pyproject():
+    """
+    Keep package version declarations consistent.
+
+    Cursor/Copilot bots frequently flag mismatches between:
+    - automation/pyproject.toml [project].version
+    - automation/jleechanorg_pr_automation/__init__.py __version__
+    """
+    pyproject_path = Path(__file__).resolve().parents[2] / "pyproject.toml"
+    if not pyproject_path.exists():
+        pytest.skip(f"pyproject not found at {pyproject_path}")
+
+    pyproject_version = _version_from_pyproject(pyproject_path)
+    if pyproject_version is None:
+        pytest.fail(f"Unable to parse [project].version from {pyproject_path}")
+    assert jleechanorg_pr_automation.__version__ == pyproject_version