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

jleechanorg_pr_automation/tests/test_pr_filtering_matrix.py

@@ -8,12 +8,9 @@ Test Matrix Coverage:
 - Eligible PR Detection and Filtering
 """
 
-import os
-import unittest
 import tempfile
-import subprocess
-from datetime import datetime, timedelta
-from unittest.mock import Mock, patch, MagicMock
+import unittest
+from unittest.mock import Mock, patch
 
 from jleechanorg_pr_automation.jleechanorg_pr_monitor import JleechanorgPRMonitor
 
@@ -24,7 +21,7 @@ class TestPRFilteringMatrix(unittest.TestCase):
     def setUp(self):
         """Set up test environment"""
         self.temp_dir = tempfile.mkdtemp()
-        self.monitor = JleechanorgPRMonitor()
+        self.monitor = JleechanorgPRMonitor(automation_username="test-automation-user")
         self.monitor.history_storage_path = self.temp_dir
 
     def tearDown(self):
@@ -36,14 +33,14 @@ class TestPRFilteringMatrix(unittest.TestCase):
     def test_matrix_open_pr_new_commit_never_processed_should_be_actionable(self):
         """RED: Open PR with new commit, never processed → Should be actionable"""
         pr_data = {
-            'number': 1001,
-            'title': 'Test PR',
-            'state': 'open',
-            'isDraft': False,
-            'headRefName': 'feature-branch',
-            'repository': 'test-repo',
-            'repositoryFullName': 'org/test-repo',
-            'headRefOid': 'abc123new'
+            "number": 1001,
+            "title": "Test PR",
+            "state": "open",
+            "isDraft": False,
+            "headRefName": "feature-branch",
+            "repository": "test-repo",
+            "repositoryFullName": "org/test-repo",
+            "headRefOid": "abc123new"
         }
 
         # RED: This will fail - no is_pr_actionable method exists
@@ -53,18 +50,18 @@ class TestPRFilteringMatrix(unittest.TestCase):
     def test_matrix_open_pr_same_commit_already_processed_should_not_be_actionable(self):
         """RED: Open PR with same commit, already processed → Should not be actionable"""
         pr_data = {
-            'number': 1001,
-            'title': 'Test PR',
-            'state': 'open',
-            'isDraft': False,
-            'headRefName': 'feature-branch',
-            'repository': 'test-repo',
-            'repositoryFullName': 'org/test-repo',
-            'headRefOid': 'abc123same'
+            "number": 1001,
+            "title": "Test PR",
+            "state": "open",
+            "isDraft": False,
+            "headRefName": "feature-branch",
+            "repository": "test-repo",
+            "repositoryFullName": "org/test-repo",
+            "headRefOid": "abc123same"
         }
 
         # Simulate previous processing
-        self.monitor._record_pr_processing('test-repo', 'feature-branch', 1001, 'abc123same')
+        self.monitor._record_pr_processing("test-repo", "feature-branch", 1001, "abc123same")
 
         # RED: This will fail - no is_pr_actionable method exists
         result = self.monitor.is_pr_actionable(pr_data)
@@ -73,18 +70,18 @@ class TestPRFilteringMatrix(unittest.TestCase):
     def test_matrix_open_pr_new_commit_old_commit_processed_should_be_actionable(self):
         """RED: Open PR with new commit, old commit processed → Should be actionable"""
         pr_data = {
-            'number': 1001,
-            'title': 'Test PR',
-            'state': 'open',
-            'isDraft': False,
-            'headRefName': 'feature-branch',
-            'repository': 'test-repo',
-            'repositoryFullName': 'org/test-repo',
-            'headRefOid': 'abc123new'
+            "number": 1001,
+            "title": "Test PR",
+            "state": "open",
+            "isDraft": False,
+            "headRefName": "feature-branch",
+            "repository": "test-repo",
+            "repositoryFullName": "org/test-repo",
+            "headRefOid": "abc123new"
         }
 
         # Simulate processing of old commit
-        self.monitor._record_pr_processing('test-repo', 'feature-branch', 1001, 'abc123old')
+        self.monitor._record_pr_processing("test-repo", "feature-branch", 1001, "abc123old")
 
         # RED: This will fail - no is_pr_actionable method exists
         result = self.monitor.is_pr_actionable(pr_data)
@@ -93,48 +90,47 @@ class TestPRFilteringMatrix(unittest.TestCase):
     def test_matrix_closed_pr_any_commit_should_not_be_actionable(self):
         """RED: Closed PR with any commit → Should not be actionable"""
         pr_data = {
-            'number': 1001,
-            'title': 'Test PR',
-            'state': 'closed',
-            'isDraft': False,
-            'headRefName': 'feature-branch',
-            'repository': 'test-repo',
-            'repositoryFullName': 'org/test-repo',
-            'headRefOid': 'abc123new'
+            "number": 1001,
+            "title": "Test PR",
+            "state": "closed",
+            "isDraft": False,
+            "headRefName": "feature-branch",
+            "repository": "test-repo",
+            "repositoryFullName": "org/test-repo",
+            "headRefOid": "abc123new"
         }
 
         # RED: This will fail - no is_pr_actionable method exists
         result = self.monitor.is_pr_actionable(pr_data)
         self.assertFalse(result)
 
-    def test_matrix_draft_pr_new_commit_never_processed_should_be_actionable(self):
-        """RED: Draft PR with new commit, never processed → Should be actionable"""
+    def test_matrix_draft_pr_new_commit_never_processed_should_be_skipped(self):
+        """Draft PRs are skipped even with new commits"""
         pr_data = {
-            'number': 1001,
-            'title': 'Test PR',
-            'state': 'open',
-            'isDraft': True,
-            'headRefName': 'feature-branch',
-            'repository': 'test-repo',
-            'repositoryFullName': 'org/test-repo',
-            'headRefOid': 'abc123new'
+            "number": 1001,
+            "title": "Test PR",
+            "state": "open",
+            "isDraft": True,
+            "headRefName": "feature-branch",
+            "repository": "test-repo",
+            "repositoryFullName": "org/test-repo",
+            "headRefOid": "abc123new"
         }
 
-        # RED: This will fail - no is_pr_actionable method exists
         result = self.monitor.is_pr_actionable(pr_data)
-        self.assertTrue(result)
+        self.assertFalse(result)
 
     def test_matrix_open_pr_no_commits_should_not_be_actionable(self):
         """RED: Open PR with no commits → Should not be actionable"""
         pr_data = {
-            'number': 1001,
-            'title': 'Test PR',
-            'state': 'open',
-            'isDraft': False,
-            'headRefName': 'feature-branch',
-            'repository': 'test-repo',
-            'repositoryFullName': 'org/test-repo',
-            'headRefOid': None  # No commits
+            "number": 1001,
+            "title": "Test PR",
+            "state": "open",
+            "isDraft": False,
+            "headRefName": "feature-branch",
+            "repository": "test-repo",
+            "repositoryFullName": "org/test-repo",
+            "headRefOid": None  # No commits
         }
 
         # RED: This will fail - no is_pr_actionable method exists
@@ -148,14 +144,14 @@ class TestPRFilteringMatrix(unittest.TestCase):
         eligible_prs = []
         for i in range(15):
             pr = {
-                'number': 1000 + i,
-                'title': f'Test PR {i}',
-                'state': 'open',
-                'isDraft': False,
-                'headRefName': f'feature-branch-{i}',
-                'repository': 'test-repo',
-                'repositoryFullName': 'org/test-repo',
-                'headRefOid': f'abc123{i:03d}'
+                "number": 1000 + i,
+                "title": f"Test PR {i}",
+                "state": "open",
+                "isDraft": False,
+                "headRefName": f"feature-branch-{i}",
+                "repository": "test-repo",
+                "repositoryFullName": "org/test-repo",
+                "headRefOid": f"abc123{i:03d}"
             }
             eligible_prs.append(pr)
 
@@ -169,14 +165,14 @@ class TestPRFilteringMatrix(unittest.TestCase):
         eligible_prs = []
         for i in range(5):
             pr = {
-                'number': 1000 + i,
-                'title': f'Test PR {i}',
-                'state': 'open',
-                'isDraft': False,
-                'headRefName': f'feature-branch-{i}',
-                'repository': 'test-repo',
-                'repositoryFullName': 'org/test-repo',
-                'headRefOid': f'abc123{i:03d}'
+                "number": 1000 + i,
+                "title": f"Test PR {i}",
+                "state": "open",
+                "isDraft": False,
+                "headRefName": f"feature-branch-{i}",
+                "repository": "test-repo",
+                "repositoryFullName": "org/test-repo",
+                "headRefOid": f"abc123{i:03d}"
             }
             eligible_prs.append(pr)
 
@@ -200,31 +196,31 @@ class TestPRFilteringMatrix(unittest.TestCase):
         # 5 actionable PRs
         for i in range(5):
             pr = {
-                'number': 1000 + i,
-                'title': f'Actionable PR {i}',
-                'state': 'open',
-                'isDraft': False,
-                'headRefName': f'feature-branch-{i}',
-                'repository': 'test-repo',
-                'repositoryFullName': 'org/test-repo',
-                'headRefOid': f'abc123new{i:03d}'
+                "number": 1000 + i,
+                "title": f"Actionable PR {i}",
+                "state": "open",
+                "isDraft": False,
+                "headRefName": f"feature-branch-{i}",
+                "repository": "test-repo",
+                "repositoryFullName": "org/test-repo",
+                "headRefOid": f"abc123new{i:03d}"
             }
             all_prs.append(pr)
 
         # 3 already processed PRs (should be skipped)
         for i in range(3):
             pr = {
-                'number': 2000 + i,
-                'title': f'Processed PR {i}',
-                'state': 'open',
-                'isDraft': False,
-                'headRefName': f'processed-branch-{i}',
-                'repository': 'test-repo',
-                'repositoryFullName': 'org/test-repo',
-                'headRefOid': f'abc123old{i:03d}'
+                "number": 2000 + i,
+                "title": f"Processed PR {i}",
+                "state": "open",
+                "isDraft": False,
+                "headRefName": f"processed-branch-{i}",
+                "repository": "test-repo",
+                "repositoryFullName": "org/test-repo",
+                "headRefOid": f"abc123old{i:03d}"
             }
             # Pre-record as processed
-            self.monitor._record_pr_processing('test-repo', f'processed-branch-{i}', 2000 + i, f'abc123old{i:03d}')
+            self.monitor._record_pr_processing("test-repo", f"processed-branch-{i}", 2000 + i, f"abc123old{i:03d}")
             all_prs.append(pr)
 
         # RED: This will fail - no filter_and_process_prs method exists
@@ -233,47 +229,46 @@ class TestPRFilteringMatrix(unittest.TestCase):
 
     # Matrix 3: Eligible PR Detection
     def test_matrix_filter_eligible_prs_from_mixed_list(self):
-        """RED: Filter eligible PRs from mixed list → Should return only actionable ones"""
+        """Filter eligible PRs from mixed list skips drafts"""
         mixed_prs = [
             # Actionable: Open, new commit
             {
-                'number': 1001, 'state': 'open', 'isDraft': False,
-                'headRefOid': 'new123', 'repository': 'repo1',
-                'headRefName': 'branch1', 'repositoryFullName': 'org/repo1'
+                "number": 1001, "state": "open", "isDraft": False,
+                "headRefOid": "new123", "repository": "repo1",
+                "headRefName": "branch1", "repositoryFullName": "org/repo1"
             },
             # Not actionable: Closed
             {
-                'number': 1002, 'state': 'closed', 'isDraft': False,
-                'headRefOid': 'new456', 'repository': 'repo2',
-                'headRefName': 'branch2', 'repositoryFullName': 'org/repo2'
+                "number": 1002, "state": "closed", "isDraft": False,
+                "headRefOid": "new456", "repository": "repo2",
+                "headRefName": "branch2", "repositoryFullName": "org/repo2"
             },
             # Not actionable: Already processed
             {
-                'number': 1003, 'state': 'open', 'isDraft': False,
-                'headRefOid': 'old789', 'repository': 'repo3',
-                'headRefName': 'branch3', 'repositoryFullName': 'org/repo3'
+                "number": 1003, "state": "open", "isDraft": False,
+                "headRefOid": "old789", "repository": "repo3",
+                "headRefName": "branch3", "repositoryFullName": "org/repo3"
             },
-            # Actionable: Draft but new commit
+            # Skipped: Draft even with new commit
             {
-                'number': 1004, 'state': 'open', 'isDraft': True,
-                'headRefOid': 'new999', 'repository': 'repo4',
-                'headRefName': 'branch4', 'repositoryFullName': 'org/repo4'
+                "number": 1004, "state": "open", "isDraft": True,
+                "headRefOid": "new999", "repository": "repo4",
+                "headRefName": "branch4", "repositoryFullName": "org/repo4"
             }
         ]
 
         # Mark one as already processed
-        self.monitor._record_pr_processing('repo3', 'branch3', 1003, 'old789')
+        self.monitor._record_pr_processing("repo3", "branch3", 1003, "old789")
 
-        # RED: This will fail - no filter_eligible_prs method exists
         eligible_prs = self.monitor.filter_eligible_prs(mixed_prs)
 
-        # Should return only the 2 actionable PRs
-        self.assertEqual(len(eligible_prs), 2)
-        actionable_numbers = [pr['number'] for pr in eligible_prs]
+        # Should return only the 1 actionable PR (draft skipped)
+        self.assertEqual(len(eligible_prs), 1)
+        actionable_numbers = [pr["number"] for pr in eligible_prs]
         self.assertIn(1001, actionable_numbers)
-        self.assertIn(1004, actionable_numbers)
         self.assertNotIn(1002, actionable_numbers)  # Closed
         self.assertNotIn(1003, actionable_numbers)  # Already processed
+        self.assertNotIn(1004, actionable_numbers)  # Draft skipped
 
     def test_matrix_find_5_eligible_prs_from_live_data(self):
         """RED: Find 5 eligible PRs from live GitHub data → Should return 5 actionable PRs"""
@@ -288,7 +283,7 @@ class TestPRFilteringMatrix(unittest.TestCase):
             {"number": 7, "state": "open", "isDraft": False, "headRefOid": "stu901", "repository": "repo7", "headRefName": "feature7"}
         ]
 
-        with patch.object(self.monitor, 'discover_open_prs', return_value=mock_prs):
+        with patch.object(self.monitor, "discover_open_prs", return_value=mock_prs):
             eligible_prs = self.monitor.find_eligible_prs(limit=5)
             self.assertEqual(len(eligible_prs), 5)
             # All returned PRs should be actionable
@@ -298,160 +293,160 @@ class TestPRFilteringMatrix(unittest.TestCase):
     # Matrix 5: Comment Posting Return Values (Bug Fix Tests)
     def test_comment_posting_returns_posted_on_success(self):
         """GREEN: Comment posting should return 'posted' when successful"""
-        with patch.object(self.monitor, '_get_pr_comment_state') as mock_state, \
-             patch.object(self.monitor, '_should_skip_pr') as mock_skip, \
-             patch.object(self.monitor, '_has_codex_comment_for_commit') as mock_has_comment, \
-             patch.object(self.monitor, '_build_codex_comment_body_simple') as mock_build_body, \
-             patch.object(self.monitor, '_record_processed_pr') as mock_record, \
-             patch('jleechanorg_pr_automation.automation_utils.AutomationUtils.execute_subprocess_with_timeout') as mock_subprocess:
+        with patch.object(self.monitor, "_get_pr_comment_state") as mock_state, \
+             patch.object(self.monitor, "_should_skip_pr") as mock_skip, \
+             patch.object(self.monitor, "_has_codex_comment_for_commit") as mock_has_comment, \
+             patch.object(self.monitor, "_build_codex_comment_body_simple") as mock_build_body, \
+             patch.object(self.monitor, "_record_processed_pr") as mock_record, \
+             patch("jleechanorg_pr_automation.automation_utils.AutomationUtils.execute_subprocess_with_timeout") as mock_subprocess:
 
             # Setup: PR not skipped, no existing comment, successful command
-            mock_state.return_value = ('sha123', [])
+            mock_state.return_value = ("sha123", [])
             mock_skip.return_value = False
             mock_has_comment.return_value = False
-            mock_build_body.return_value = 'Test comment body'
-            mock_subprocess.return_value = Mock(returncode=0, stdout='success', stderr='')
+            mock_build_body.return_value = "Test comment body"
+            mock_subprocess.return_value = Mock(returncode=0, stdout="success", stderr="")
 
             pr_data = {
-                'repositoryFullName': 'org/repo',
-                'headRefName': 'feature'
+                "repositoryFullName": "org/repo",
+                "headRefName": "feature"
             }
 
-            result = self.monitor.post_codex_instruction_simple('org/repo', 123, pr_data)
-            self.assertEqual(result, 'posted')
+            result = self.monitor.post_codex_instruction_simple("org/repo", 123, pr_data)
+            self.assertEqual(result, "posted")
             mock_record.assert_called_once()
 
     def test_comment_posting_returns_skipped_when_already_processed(self):
         """GREEN: Comment posting should return 'skipped' when PR already processed"""
-        with patch.object(self.monitor, '_get_pr_comment_state') as mock_state, \
-             patch.object(self.monitor, '_should_skip_pr') as mock_skip:
+        with patch.object(self.monitor, "_get_pr_comment_state") as mock_state, \
+             patch.object(self.monitor, "_should_skip_pr") as mock_skip:
 
             # Setup: PR should be skipped
-            mock_state.return_value = ('sha123', [])
+            mock_state.return_value = ("sha123", [])
             mock_skip.return_value = True
 
             pr_data = {
-                'repositoryFullName': 'org/repo',
-                'headRefName': 'feature'
+                "repositoryFullName": "org/repo",
+                "headRefName": "feature"
             }
 
-            result = self.monitor.post_codex_instruction_simple('org/repo', 123, pr_data)
-            self.assertEqual(result, 'skipped')
+            result = self.monitor.post_codex_instruction_simple("org/repo", 123, pr_data)
+            self.assertEqual(result, "skipped")
 
     def test_comment_posting_returns_skipped_when_comment_exists(self):
         """GREEN: Comment posting should return 'skipped' when comment already exists for commit"""
-        with patch.object(self.monitor, '_get_pr_comment_state') as mock_state, \
-             patch.object(self.monitor, '_should_skip_pr') as mock_skip, \
-             patch.object(self.monitor, '_has_codex_comment_for_commit') as mock_has_comment:
+        with patch.object(self.monitor, "_get_pr_comment_state") as mock_state, \
+             patch.object(self.monitor, "_should_skip_pr") as mock_skip, \
+             patch.object(self.monitor, "_has_codex_comment_for_commit") as mock_has_comment:
 
             # Setup: PR not skipped but has existing comment
-            mock_state.return_value = ('sha123', [])
+            mock_state.return_value = ("sha123", [])
             mock_skip.return_value = False
             mock_has_comment.return_value = True
 
             pr_data = {
-                'repositoryFullName': 'org/repo',
-                'headRefName': 'feature'
+                "repositoryFullName": "org/repo",
+                "headRefName": "feature"
             }
 
-            result = self.monitor.post_codex_instruction_simple('org/repo', 123, pr_data)
-            self.assertEqual(result, 'skipped')
+            result = self.monitor.post_codex_instruction_simple("org/repo", 123, pr_data)
+            self.assertEqual(result, "skipped")
 
     def test_comment_posting_returns_failed_on_subprocess_error(self):
         """GREEN: Comment posting should return 'failed' when subprocess fails"""
-        with patch.object(self.monitor, '_get_pr_comment_state') as mock_state, \
-             patch.object(self.monitor, '_should_skip_pr') as mock_skip, \
-             patch.object(self.monitor, '_has_codex_comment_for_commit') as mock_has_comment, \
-             patch.object(self.monitor, '_build_codex_comment_body_simple') as mock_build_body, \
-             patch('jleechanorg_pr_automation.automation_utils.AutomationUtils.execute_subprocess_with_timeout') as mock_subprocess:
+        with patch.object(self.monitor, "_get_pr_comment_state") as mock_state, \
+             patch.object(self.monitor, "_should_skip_pr") as mock_skip, \
+             patch.object(self.monitor, "_has_codex_comment_for_commit") as mock_has_comment, \
+             patch.object(self.monitor, "_build_codex_comment_body_simple") as mock_build_body, \
+             patch("jleechanorg_pr_automation.automation_utils.AutomationUtils.execute_subprocess_with_timeout") as mock_subprocess:
 
             # Setup: PR not skipped, no existing comment, but command fails
-            mock_state.return_value = ('sha123', [])
+            mock_state.return_value = ("sha123", [])
             mock_skip.return_value = False
             mock_has_comment.return_value = False
-            mock_build_body.return_value = 'Test comment body'
-            mock_subprocess.side_effect = Exception('Command failed')
+            mock_build_body.return_value = "Test comment body"
+            mock_subprocess.side_effect = Exception("Command failed")
 
             pr_data = {
-                'repositoryFullName': 'org/repo',
-                'headRefName': 'feature'
+                "repositoryFullName": "org/repo",
+                "headRefName": "feature"
             }
 
-            result = self.monitor.post_codex_instruction_simple('org/repo', 123, pr_data)
-            self.assertEqual(result, 'failed')
+            result = self.monitor.post_codex_instruction_simple("org/repo", 123, pr_data)
+            self.assertEqual(result, "failed")
 
     def test_comment_posting_skips_when_head_commit_from_codex(self):
         """GREEN: post_codex_instruction_simple should skip when head commit is Codex-attributed"""
-        with patch.object(self.monitor, '_get_pr_comment_state') as mock_state, \
-             patch.object(self.monitor, '_get_head_commit_details') as mock_head_details, \
-             patch.object(self.monitor, '_is_head_commit_from_codex') as mock_is_codex, \
-             patch.object(self.monitor, '_should_skip_pr') as mock_should_skip, \
-             patch.object(self.monitor, '_has_codex_comment_for_commit') as mock_has_comment, \
-             patch.object(self.monitor, '_record_processed_pr') as mock_record_processed, \
-             patch.object(self.monitor, '_build_codex_comment_body_simple') as mock_build_body, \
-             patch('jleechanorg_pr_automation.automation_utils.AutomationUtils.execute_subprocess_with_timeout') as mock_subprocess:
-
-            mock_state.return_value = ('sha123', [])
-            mock_head_details.return_value = {'sha': 'sha123'}
+        with patch.object(self.monitor, "_get_pr_comment_state") as mock_state, \
+             patch.object(self.monitor, "_get_head_commit_details") as mock_head_details, \
+             patch.object(self.monitor, "_is_head_commit_from_codex") as mock_is_codex, \
+             patch.object(self.monitor, "_should_skip_pr") as mock_should_skip, \
+             patch.object(self.monitor, "_has_codex_comment_for_commit") as mock_has_comment, \
+             patch.object(self.monitor, "_record_processed_pr") as mock_record_processed, \
+             patch.object(self.monitor, "_build_codex_comment_body_simple") as mock_build_body, \
+             patch("jleechanorg_pr_automation.automation_utils.AutomationUtils.execute_subprocess_with_timeout") as mock_subprocess:
+
+            mock_state.return_value = ("sha123", [])
+            mock_head_details.return_value = {"sha": "sha123"}
             mock_is_codex.return_value = True
 
             pr_data = {
-                'repositoryFullName': 'org/repo',
-                'headRefName': 'feature',
+                "repositoryFullName": "org/repo",
+                "headRefName": "feature",
             }
 
-            result = self.monitor.post_codex_instruction_simple('org/repo', 456, pr_data)
+            result = self.monitor.post_codex_instruction_simple("org/repo", 456, pr_data)
 
-            self.assertEqual(result, 'skipped')
-            mock_is_codex.assert_called_once_with({'sha': 'sha123'})
+            self.assertEqual(result, "skipped")
+            mock_is_codex.assert_called_once_with({"sha": "sha123"})
             mock_should_skip.assert_not_called()
             mock_has_comment.assert_not_called()
             mock_build_body.assert_not_called()
             mock_subprocess.assert_not_called()
-            mock_record_processed.assert_called_once_with('repo', 'feature', 456, 'sha123')
+            mock_record_processed.assert_called_once_with("repo", "feature", 456, "sha123")
 
     def test_process_pr_comment_only_returns_true_for_posted(self):
         """GREEN: _process_pr_comment should only return True when comment actually posted"""
-        with patch.object(self.monitor, 'post_codex_instruction_simple') as mock_post:
+        with patch.object(self.monitor, "post_codex_instruction_simple") as mock_post:
 
-            pr_data = {'repositoryFullName': 'org/repo'}
+            pr_data = {"repositoryFullName": "org/repo"}
 
             # Test: Returns True only for 'posted'
-            mock_post.return_value = 'posted'
-            self.assertTrue(self.monitor._process_pr_comment('repo', 123, pr_data))
+            mock_post.return_value = "posted"
+            self.assertTrue(self.monitor._process_pr_comment("repo", 123, pr_data))
 
             # Test: Returns False for 'skipped'
-            mock_post.return_value = 'skipped'
-            self.assertFalse(self.monitor._process_pr_comment('repo', 123, pr_data))
+            mock_post.return_value = "skipped"
+            self.assertFalse(self.monitor._process_pr_comment("repo", 123, pr_data))
 
             # Test: Returns False for 'failed'
-            mock_post.return_value = 'failed'
-            self.assertFalse(self.monitor._process_pr_comment('repo', 123, pr_data))
+            mock_post.return_value = "failed"
+            self.assertFalse(self.monitor._process_pr_comment("repo", 123, pr_data))
 
     def test_comment_template_contains_all_ai_assistants(self):
         """GREEN: Comment template should mention all 4 AI assistants"""
         pr_data = {
-            'title': 'Test PR',
-            'author': {'login': 'testuser'},
-            'headRefName': 'test-branch'
+            "title": "Test PR",
+            "author": {"login": "testuser"},
+            "headRefName": "test-branch"
         }
 
         comment_body = self.monitor._build_codex_comment_body_simple(
-            'test/repo', 123, pr_data, 'abc12345'
+            "test/repo", 123, pr_data, "abc12345"
         )
 
         # Verify all 4 AI assistant mentions are present
-        self.assertIn('@codex', comment_body, "Comment should mention @codex")
-        self.assertIn('@coderabbitai', comment_body, "Comment should mention @coderabbitai")
-        self.assertIn('@copilot', comment_body, "Comment should mention @copilot")
-        self.assertIn('@cursor', comment_body, "Comment should mention @cursor")
+        self.assertIn("@codex", comment_body, "Comment should mention @codex")
+        self.assertIn("@coderabbitai", comment_body, "Comment should mention @coderabbitai")
+        self.assertIn("@copilot", comment_body, "Comment should mention @copilot")
+        self.assertIn("@cursor", comment_body, "Comment should mention @cursor")
 
         # Verify they appear at the beginning of the comment
-        first_line = comment_body.split('\n')[0]
-        self.assertIn('@codex', first_line, "@codex should be in first line")
-        self.assertIn('@coderabbitai', first_line, "@coderabbitai should be in first line")
-        self.assertIn('@copilot', first_line, "@copilot should be in first line")
-        self.assertIn('@cursor', first_line, "@cursor should be in first line")
+        first_line = comment_body.split("\n")[0]
+        self.assertIn("@codex", first_line, "@codex should be in first line")
+        self.assertIn("@coderabbitai", first_line, "@coderabbitai should be in first line")
+        self.assertIn("@copilot", first_line, "@copilot should be in first line")
+        self.assertIn("@cursor", first_line, "@cursor should be in first line")
 
         # Verify automation marker instructions are documented
         self.assertIn(
@@ -465,8 +460,66 @@ class TestPRFilteringMatrix(unittest.TestCase):
             "Comment should remind Codex about the hidden commit marker",
         )
 
+    def test_fix_comment_review_body_includes_greptile(self):
+        """Fix-comment review body should include Greptile + standard bot mentions."""
+        pr_data = {
+            "title": "Test PR",
+            "author": {"login": "dev"},
+            "headRefName": "feature-branch",
+        }
+
+        comment_body = self.monitor._build_fix_comment_review_body(
+            "org/repo",
+            123,
+            pr_data,
+            "abc123",
+        )
+
+        self.assertIn("@greptile", comment_body)
+        self.assertIn("@codex", comment_body)
+        self.assertIn(self.monitor.FIX_COMMENT_MARKER_PREFIX, comment_body)
+
+    def test_fix_comment_prompt_requires_gh_comment_replies(self):
+        """Fix-comment prompt should require gh pr comment replies for 100% of comments."""
+        pr_data = {
+            "title": "Test PR",
+            "author": {"login": "dev"},
+            "headRefName": "feature-branch",
+        }
+
+        prompt_body = self.monitor._build_fix_comment_prompt_body(
+            "org/repo",
+            123,
+            pr_data,
+            "abc123",
+            "gemini",
+        )
+
+        self.assertIn("gh pr comment", prompt_body)
+        self.assertIn("reply to **100%** of comments INDIVIDUALLY", prompt_body)
+
+    def test_fix_comment_mode_dispatches_agent(self):
+        """Fix-comment processing should dispatch orchestration agent and post comments."""
+        pr_data = {
+            "title": "Test PR",
+            "author": {"login": "dev"},
+            "headRefName": "feature-branch",
+            "repositoryFullName": "org/repo",
+        }
+
+        with patch.object(self.monitor, "_get_pr_comment_state", return_value=("abc123", [])), \
+             patch.object(self.monitor, "_should_skip_pr", return_value=False), \
+             patch.object(self.monitor, "_has_fix_comment_comment_for_commit", return_value=False), \
+             patch.object(self.monitor, "dispatch_fix_comment_agent", return_value=True), \
+             patch.object(self.monitor, "_post_fix_comment_queued", return_value=True), \
+             patch.object(self.monitor, "_start_fix_comment_review_watcher", return_value=True) as mock_start:
+
+            result = self.monitor._process_pr_fix_comment("org/repo", 123, pr_data, agent_cli="gemini")
+            self.assertEqual(result, "posted")
+            mock_start.assert_called_once()
+
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # RED Phase: Run tests to confirm they FAIL
     print("🔴 RED Phase: Running failing tests for PR filtering matrix")
     print("Expected: ALL TESTS SHOULD FAIL (no implementation exists)")