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

jleechanorg_pr_automation/tests/test_actionable_counting_matrix.py

@@ -6,11 +6,9 @@ Test Matrix: Actionable PR counting should exclude skipped PRs and only count
 PRs that actually get processed with comments.
 """
 
-import os
-import unittest
 import tempfile
-from datetime import datetime, timedelta
-from unittest.mock import Mock, patch, MagicMock
+import unittest
+from unittest.mock import patch
 
 from jleechanorg_pr_automation.jleechanorg_pr_monitor import JleechanorgPRMonitor
 
@@ -21,7 +19,7 @@ class TestActionableCountingMatrix(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):
@@ -35,40 +33,40 @@ class TestActionableCountingMatrix(unittest.TestCase):
         # Create a mix of PRs - some actionable, some should be skipped
         mock_prs = [
             # 3 actionable PRs (new commits)
-            {'number': 1001, 'state': 'open', 'isDraft': False, 'headRefOid': 'new001',
-             'repository': 'repo1', 'headRefName': 'feature1', 'repositoryFullName': 'org/repo1',
-             'title': 'Actionable PR 1', 'updatedAt': '2025-09-28T21:00:00Z'},
-            {'number': 1002, 'state': 'open', 'isDraft': False, 'headRefOid': 'new002',
-             'repository': 'repo2', 'headRefName': 'feature2', 'repositoryFullName': 'org/repo2',
-             'title': 'Actionable PR 2', 'updatedAt': '2025-09-28T20:59:00Z'},
-            {'number': 1003, 'state': 'open', 'isDraft': False, 'headRefOid': 'new003',
-             'repository': 'repo3', 'headRefName': 'feature3', 'repositoryFullName': 'org/repo3',
-             'title': 'Actionable PR 3', 'updatedAt': '2025-09-28T20:58:00Z'},
+            {"number": 1001, "state": "open", "isDraft": False, "headRefOid": "new001",
+             "repository": "repo1", "headRefName": "feature1", "repositoryFullName": "org/repo1",
+             "title": "Actionable PR 1", "updatedAt": "2025-09-28T21:00:00Z"},
+            {"number": 1002, "state": "open", "isDraft": False, "headRefOid": "new002",
+             "repository": "repo2", "headRefName": "feature2", "repositoryFullName": "org/repo2",
+             "title": "Actionable PR 2", "updatedAt": "2025-09-28T20:59:00Z"},
+            {"number": 1003, "state": "open", "isDraft": False, "headRefOid": "new003",
+             "repository": "repo3", "headRefName": "feature3", "repositoryFullName": "org/repo3",
+             "title": "Actionable PR 3", "updatedAt": "2025-09-28T20:58:00Z"},
 
             # 2 PRs that should be skipped (already processed)
-            {'number': 2001, 'state': 'open', 'isDraft': False, 'headRefOid': 'old001',
-             'repository': 'repo4', 'headRefName': 'processed1', 'repositoryFullName': 'org/repo4',
-             'title': 'Already Processed PR 1', 'updatedAt': '2025-09-28T20:57:00Z'},
-            {'number': 2002, 'state': 'open', 'isDraft': False, 'headRefOid': 'old002',
-             'repository': 'repo5', 'headRefName': 'processed2', 'repositoryFullName': 'org/repo5',
-             'title': 'Already Processed PR 2', 'updatedAt': '2025-09-28T20:56:00Z'}
+            {"number": 2001, "state": "open", "isDraft": False, "headRefOid": "old001",
+             "repository": "repo4", "headRefName": "processed1", "repositoryFullName": "org/repo4",
+             "title": "Already Processed PR 1", "updatedAt": "2025-09-28T20:57:00Z"},
+            {"number": 2002, "state": "open", "isDraft": False, "headRefOid": "old002",
+             "repository": "repo5", "headRefName": "processed2", "repositoryFullName": "org/repo5",
+             "title": "Already Processed PR 2", "updatedAt": "2025-09-28T20:56:00Z"}
         ]
 
         # Pre-record the "processed" PRs as already handled
-        self.monitor._record_pr_processing('repo4', 'processed1', 2001, 'old001')
-        self.monitor._record_pr_processing('repo5', 'processed2', 2002, 'old002')
+        self.monitor._record_pr_processing("repo4", "processed1", 2001, "old001")
+        self.monitor._record_pr_processing("repo5", "processed2", 2002, "old002")
 
         # Mock the PR discovery to return our test data
-        with patch.object(self.monitor, 'discover_open_prs', return_value=mock_prs):
-            with patch.object(self.monitor, '_process_pr_comment', return_value=True) as mock_process:
+        with patch.object(self.monitor, "discover_open_prs", return_value=mock_prs):
+            with patch.object(self.monitor, "_process_pr_comment", return_value=True) as mock_process:
 
                 # RED: This should fail - current implementation counts all PRs, not just actionable ones
                 result = self.monitor.run_monitoring_cycle_with_actionable_count(target_actionable_count=3)
 
                 # Should process exactly 3 actionable PRs, not counting the 2 skipped ones
-                self.assertEqual(result['actionable_processed'], 3)
-                self.assertEqual(result['total_discovered'], 5)
-                self.assertEqual(result['skipped_count'], 2)
+                self.assertEqual(result["actionable_processed"], 3)
+                self.assertEqual(result["total_discovered"], 5)
+                self.assertEqual(result["skipped_count"], 2)
 
                 # Verify that _process_pr_comment was called exactly 3 times (only for actionable PRs)
                 self.assertEqual(mock_process.call_count, 3)
@@ -78,35 +76,35 @@ class TestActionableCountingMatrix(unittest.TestCase):
 
         # Create only 2 actionable PRs, but set target to 5
         mock_prs = [
-            {'number': 1001, 'state': 'open', 'isDraft': False, 'headRefOid': 'new001',
-             'repository': 'repo1', 'headRefName': 'feature1', 'repositoryFullName': 'org/repo1',
-             'title': 'Actionable PR 1', 'updatedAt': '2025-09-28T21:00:00Z'},
-            {'number': 1002, 'state': 'open', 'isDraft': False, 'headRefOid': 'new002',
-             'repository': 'repo2', 'headRefName': 'feature2', 'repositoryFullName': 'org/repo2',
-             'title': 'Actionable PR 2', 'updatedAt': '2025-09-28T20:59:00Z'},
+            {"number": 1001, "state": "open", "isDraft": False, "headRefOid": "new001",
+             "repository": "repo1", "headRefName": "feature1", "repositoryFullName": "org/repo1",
+             "title": "Actionable PR 1", "updatedAt": "2025-09-28T21:00:00Z"},
+            {"number": 1002, "state": "open", "isDraft": False, "headRefOid": "new002",
+             "repository": "repo2", "headRefName": "feature2", "repositoryFullName": "org/repo2",
+             "title": "Actionable PR 2", "updatedAt": "2025-09-28T20:59:00Z"},
 
             # 3 closed/processed PRs (not actionable)
-            {'number': 2001, 'state': 'closed', 'isDraft': False, 'headRefOid': 'any001',
-             'repository': 'repo3', 'headRefName': 'closed1', 'repositoryFullName': 'org/repo3',
-             'title': 'Closed PR', 'updatedAt': '2025-09-28T20:58:00Z'},
-            {'number': 2002, 'state': 'open', 'isDraft': False, 'headRefOid': 'old002',
-             'repository': 'repo4', 'headRefName': 'processed2', 'repositoryFullName': 'org/repo4',
-             'title': 'Processed PR', 'updatedAt': '2025-09-28T20:57:00Z'}
+            {"number": 2001, "state": "closed", "isDraft": False, "headRefOid": "any001",
+             "repository": "repo3", "headRefName": "closed1", "repositoryFullName": "org/repo3",
+             "title": "Closed PR", "updatedAt": "2025-09-28T20:58:00Z"},
+            {"number": 2002, "state": "open", "isDraft": False, "headRefOid": "old002",
+             "repository": "repo4", "headRefName": "processed2", "repositoryFullName": "org/repo4",
+             "title": "Processed PR", "updatedAt": "2025-09-28T20:57:00Z"}
         ]
 
         # Pre-record one as processed
-        self.monitor._record_pr_processing('repo4', 'processed2', 2002, 'old002')
+        self.monitor._record_pr_processing("repo4", "processed2", 2002, "old002")
 
-        with patch.object(self.monitor, 'discover_open_prs', return_value=mock_prs):
-            with patch.object(self.monitor, '_process_pr_comment', return_value=True) as mock_process:
+        with patch.object(self.monitor, "discover_open_prs", return_value=mock_prs):
+            with patch.object(self.monitor, "_process_pr_comment", return_value=True) as mock_process:
 
                 # RED: This should fail - method doesn't exist yet
                 result = self.monitor.run_monitoring_cycle_with_actionable_count(target_actionable_count=5)
 
                 # Should process only the 2 available actionable PRs
-                self.assertEqual(result['actionable_processed'], 2)
-                self.assertEqual(result['total_discovered'], 4)
-                self.assertEqual(result['skipped_count'], 2)  # 1 closed + 1 processed
+                self.assertEqual(result["actionable_processed"], 2)
+                self.assertEqual(result["total_discovered"], 4)
+                self.assertEqual(result["skipped_count"], 2)  # 1 closed + 1 processed
 
                 # Verify processing was called only for actionable PRs
                 self.assertEqual(mock_process.call_count, 2)
@@ -117,30 +115,30 @@ class TestActionableCountingMatrix(unittest.TestCase):
         # Create only non-actionable PRs
         mock_prs = [
             # All closed or already processed
-            {'number': 2001, 'state': 'closed', 'isDraft': False, 'headRefOid': 'any001',
-             'repository': 'repo1', 'headRefName': 'closed1', 'repositoryFullName': 'org/repo1',
-             'title': 'Closed PR 1', 'updatedAt': '2025-09-28T21:00:00Z'},
-            {'number': 2002, 'state': 'closed', 'isDraft': False, 'headRefOid': 'any002',
-             'repository': 'repo2', 'headRefName': 'closed2', 'repositoryFullName': 'org/repo2',
-             'title': 'Closed PR 2', 'updatedAt': '2025-09-28T20:59:00Z'},
-            {'number': 2003, 'state': 'open', 'isDraft': False, 'headRefOid': 'old003',
-             'repository': 'repo3', 'headRefName': 'processed3', 'repositoryFullName': 'org/repo3',
-             'title': 'Processed PR', 'updatedAt': '2025-09-28T20:58:00Z'}
+            {"number": 2001, "state": "closed", "isDraft": False, "headRefOid": "any001",
+             "repository": "repo1", "headRefName": "closed1", "repositoryFullName": "org/repo1",
+             "title": "Closed PR 1", "updatedAt": "2025-09-28T21:00:00Z"},
+            {"number": 2002, "state": "closed", "isDraft": False, "headRefOid": "any002",
+             "repository": "repo2", "headRefName": "closed2", "repositoryFullName": "org/repo2",
+             "title": "Closed PR 2", "updatedAt": "2025-09-28T20:59:00Z"},
+            {"number": 2003, "state": "open", "isDraft": False, "headRefOid": "old003",
+             "repository": "repo3", "headRefName": "processed3", "repositoryFullName": "org/repo3",
+             "title": "Processed PR", "updatedAt": "2025-09-28T20:58:00Z"}
         ]
 
         # Mark the open one as already processed
-        self.monitor._record_pr_processing('repo3', 'processed3', 2003, 'old003')
+        self.monitor._record_pr_processing("repo3", "processed3", 2003, "old003")
 
-        with patch.object(self.monitor, 'discover_open_prs', return_value=mock_prs):
-            with patch.object(self.monitor, '_process_pr_comment', return_value=True) as mock_process:
+        with patch.object(self.monitor, "discover_open_prs", return_value=mock_prs):
+            with patch.object(self.monitor, "_process_pr_comment", return_value=True) as mock_process:
 
                 # RED: This should fail - method doesn't exist yet
                 result = self.monitor.run_monitoring_cycle_with_actionable_count(target_actionable_count=10)
 
                 # Should process 0 PRs
-                self.assertEqual(result['actionable_processed'], 0)
-                self.assertEqual(result['total_discovered'], 3)
-                self.assertEqual(result['skipped_count'], 3)  # All skipped
+                self.assertEqual(result["actionable_processed"], 0)
+                self.assertEqual(result["total_discovered"], 3)
+                self.assertEqual(result["skipped_count"], 3)  # All skipped
 
                 # Verify no processing was attempted
                 self.assertEqual(mock_process.call_count, 0)
@@ -149,15 +147,15 @@ class TestActionableCountingMatrix(unittest.TestCase):
         """RED: Actionable counter should only count PRs that successfully get processed"""
 
         mock_prs = [
-            {'number': 1001, 'state': 'open', 'isDraft': False, 'headRefOid': 'new001',
-             'repository': 'repo1', 'headRefName': 'feature1', 'repositoryFullName': 'org/repo1',
-             'title': 'Success PR', 'updatedAt': '2025-09-28T21:00:00Z'},
-            {'number': 1002, 'state': 'open', 'isDraft': False, 'headRefOid': 'new002',
-             'repository': 'repo2', 'headRefName': 'feature2', 'repositoryFullName': 'org/repo2',
-             'title': 'Failure PR', 'updatedAt': '2025-09-28T20:59:00Z'},
-            {'number': 1003, 'state': 'open', 'isDraft': False, 'headRefOid': 'new003',
-             'repository': 'repo3', 'headRefName': 'feature3', 'repositoryFullName': 'org/repo3',
-             'title': 'Success PR 2', 'updatedAt': '2025-09-28T20:58:00Z'}
+            {"number": 1001, "state": "open", "isDraft": False, "headRefOid": "new001",
+             "repository": "repo1", "headRefName": "feature1", "repositoryFullName": "org/repo1",
+             "title": "Success PR", "updatedAt": "2025-09-28T21:00:00Z"},
+            {"number": 1002, "state": "open", "isDraft": False, "headRefOid": "new002",
+             "repository": "repo2", "headRefName": "feature2", "repositoryFullName": "org/repo2",
+             "title": "Failure PR", "updatedAt": "2025-09-28T20:59:00Z"},
+            {"number": 1003, "state": "open", "isDraft": False, "headRefOid": "new003",
+             "repository": "repo3", "headRefName": "feature3", "repositoryFullName": "org/repo3",
+             "title": "Success PR 2", "updatedAt": "2025-09-28T20:58:00Z"}
         ]
 
         def mock_process_side_effect(repo_name, pr_number, pr_data):
@@ -166,16 +164,16 @@ class TestActionableCountingMatrix(unittest.TestCase):
                 return False  # Processing failed
             return True  # Processing succeeded
 
-        with patch.object(self.monitor, 'discover_open_prs', return_value=mock_prs):
-            with patch.object(self.monitor, '_process_pr_comment', side_effect=mock_process_side_effect) as mock_process:
+        with patch.object(self.monitor, "discover_open_prs", return_value=mock_prs):
+            with patch.object(self.monitor, "_process_pr_comment", side_effect=mock_process_side_effect) as mock_process:
 
                 # RED: This should fail - method doesn't exist yet
                 result = self.monitor.run_monitoring_cycle_with_actionable_count(target_actionable_count=10)
 
                 # Should count only successful processing (2 out of 3 attempts)
-                self.assertEqual(result['actionable_processed'], 2)
-                self.assertEqual(result['total_discovered'], 3)
-                self.assertEqual(result['processing_failures'], 1)
+                self.assertEqual(result["actionable_processed"], 2)
+                self.assertEqual(result["total_discovered"], 3)
+                self.assertEqual(result["processing_failures"], 1)
 
                 # Verify all 3 were attempted
                 self.assertEqual(mock_process.call_count, 3)
@@ -186,35 +184,35 @@ class TestActionableCountingMatrix(unittest.TestCase):
         mock_prs = [
             # Create 15 total PRs, but only 8 should be actionable
             *[
-                {'number': 1000 + i, 'state': 'open', 'isDraft': False, 'headRefOid': f'new{i:03d}',
-                 'repository': f'repo{i}', 'headRefName': f'feature{i}', 'repositoryFullName': f'org/repo{i}',
-                 'title': f'Actionable PR {i}', 'updatedAt': f'2025-09-28T{21-i//10}:{59-(i%10)*5}:00Z'}
+                {"number": 1000 + i, "state": "open", "isDraft": False, "headRefOid": f"new{i:03d}",
+                 "repository": f"repo{i}", "headRefName": f"feature{i}", "repositoryFullName": f"org/repo{i}",
+                 "title": f"Actionable PR {i}", "updatedAt": f"2025-09-28T{21-i//10}:{59-(i%10)*5}:00Z"}
                 for i in range(8)  # 8 actionable PRs
             ],
             *[
-                {'number': 2000 + i, 'state': 'closed', 'isDraft': False, 'headRefOid': f'any{i:03d}',
-                 'repository': f'closed_repo{i}', 'headRefName': f'closed{i}', 'repositoryFullName': f'org/closed_repo{i}',
-                 'title': f'Closed PR {i}', 'updatedAt': f'2025-09-28T20:{50-i}:00Z'}
+                {"number": 2000 + i, "state": "closed", "isDraft": False, "headRefOid": f"any{i:03d}",
+                 "repository": f"closed_repo{i}", "headRefName": f"closed{i}", "repositoryFullName": f"org/closed_repo{i}",
+                 "title": f"Closed PR {i}", "updatedAt": f"2025-09-28T20:{50-i}:00Z"}
                 for i in range(7)  # 7 closed PRs (not actionable)
             ]
         ]
 
-        with patch.object(self.monitor, 'discover_open_prs', return_value=mock_prs):
-            with patch.object(self.monitor, '_process_pr_comment', return_value=True) as mock_process:
+        with patch.object(self.monitor, "discover_open_prs", return_value=mock_prs):
+            with patch.object(self.monitor, "_process_pr_comment", return_value=True) as mock_process:
 
                 # RED: This should fail - enhanced method doesn't exist
                 # Should process exactly 5 actionable PRs, ignoring the 7 closed ones
                 result = self.monitor.run_monitoring_cycle_with_actionable_count(target_actionable_count=5)
 
-                self.assertEqual(result['actionable_processed'], 5)
-                self.assertEqual(result['total_discovered'], 15)
-                self.assertEqual(result['skipped_count'], 7)  # Closed PRs
+                self.assertEqual(result["actionable_processed"], 5)
+                self.assertEqual(result["total_discovered"], 15)
+                self.assertEqual(result["skipped_count"], 7)  # Closed PRs
 
                 # Should have attempted processing exactly 5 times
                 self.assertEqual(mock_process.call_count, 5)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # RED Phase: Run tests to confirm they FAIL
     print("🔴 RED Phase: Running failing tests for actionable PR counting")
     print("Expected: ALL TESTS SHOULD FAIL (no implementation exists)")

jleechanorg_pr_automation/tests/test_attempt_limit_logic.py

@@ -0,0 +1,124 @@
+"""
+Tests for per-PR attempt limit logic
+
+NEW BEHAVIOR: Counts ALL attempts (success + failure) against the limit.
+This enables iterative improvements by allowing multiple successful runs.
+"""
+
+import json
+import os
+import shutil
+import tempfile
+import unittest
+from pathlib import Path
+
+from jleechanorg_pr_automation.automation_safety_manager import AutomationSafetyManager
+
+
+class TestAttemptLimitLogic(unittest.TestCase):
+    """Test that attempt limits count ALL attempts (success + failure)"""
+
+    def setUp(self):
+        """Set up test environment with temporary directory"""
+        self.test_dir = tempfile.mkdtemp()
+        self.safety_manager = AutomationSafetyManager(data_dir=self.test_dir)
+        # Note: Default pr_limit is now 50
+
+    def tearDown(self):
+        """Clean up test directory"""
+        shutil.rmtree(self.test_dir, ignore_errors=True)
+
+    def test_all_attempts_count_against_limit(self):
+        """All attempts (success + failure) count against pr_limit"""
+        # Create 50 successful attempts (exactly at pr_limit=50 default)
+        pr_attempts = {
+            "r=test/repo||p=123||b=main": [
+                {"result": "success", "timestamp": f"2026-01-{i:02d}T12:00:00"}
+                for i in range(1, 51)
+            ]
+        }
+
+        attempts_file = os.path.join(self.test_dir, "pr_attempts.json")
+        with open(attempts_file, "w") as f:
+            json.dump(pr_attempts, f)
+
+        # Should be blocked (50 attempts = limit)
+        can_process = self.safety_manager.can_process_pr(123, repo="test/repo", branch="main")
+        self.assertFalse(can_process, "Should block processing at 50 total attempts")
+
+    def test_failure_limit_blocks_processing(self):
+        """50 failures should block processing (pr_limit=50)"""
+        # Create 50 failed attempts (exactly at limit)
+        pr_attempts = {
+            "r=test/repo||p=456||b=main": [
+                {"result": "failure", "timestamp": f"2026-01-{i:02d}T12:00:00"}
+                for i in range(1, 51)
+            ]
+        }
+
+        attempts_file = os.path.join(self.test_dir, "pr_attempts.json")
+        with open(attempts_file, "w") as f:
+            json.dump(pr_attempts, f)
+
+        # Should be blocked (50 failures = limit)
+        can_process = self.safety_manager.can_process_pr(456, repo="test/repo", branch="main")
+        self.assertFalse(can_process, "Should block processing with 50 failed attempts")
+
+    def test_mixed_attempts_count_all(self):
+        """Mixed success/failure attempts all count toward limit"""
+        # Create 50 total attempts: 30 successes + 20 failures
+        pr_attempts = {
+            "r=test/repo||p=789||b=main": [
+                {"result": "success", "timestamp": f"2026-01-{i:02d}T12:00:00"}
+                for i in range(1, 31)
+            ] + [
+                {"result": "failure", "timestamp": f"2026-01-{i:02d}T13:00:00"}
+                for i in range(31, 51)
+            ]
+        }
+
+        attempts_file = os.path.join(self.test_dir, "pr_attempts.json")
+        with open(attempts_file, "w") as f:
+            json.dump(pr_attempts, f)
+
+        # Should be blocked (50 total attempts = limit)
+        can_process = self.safety_manager.can_process_pr(789, repo="test/repo", branch="main")
+        self.assertFalse(can_process, "Should block processing with 50 total attempts")
+
+    def test_under_limit_allows_processing(self):
+        """Under the limit (49 attempts) should allow processing"""
+        # Create 49 attempts (1 under limit)
+        pr_attempts = {
+            "r=test/repo||p=999||b=main": [
+                {"result": "success", "timestamp": f"2026-01-{i:02d}T12:00:00"}
+                for i in range(1, 30)
+            ] + [
+                {"result": "failure", "timestamp": f"2026-01-{i:02d}T13:00:00"}
+                for i in range(30, 50)
+            ]
+        }
+
+        attempts_file = os.path.join(self.test_dir, "pr_attempts.json")
+        with open(attempts_file, "w") as f:
+            json.dump(pr_attempts, f)
+
+        # Should allow processing (49 < 50 limit)
+        can_process = self.safety_manager.can_process_pr(999, repo="test/repo", branch="main")
+        self.assertTrue(can_process, "Should allow processing with 49 total attempts")
+
+    def test_no_attempts_allows_processing(self):
+        """No attempts should allow processing"""
+        # Empty attempts
+        pr_attempts = {}
+
+        attempts_file = os.path.join(self.test_dir, "pr_attempts.json")
+        with open(attempts_file, "w") as f:
+            json.dump(pr_attempts, f)
+
+        # Should allow processing (0 attempts)
+        can_process = self.safety_manager.can_process_pr(111, repo="test/repo", branch="main")
+        self.assertTrue(can_process, "Should allow processing with 0 attempts")
+
+
+if __name__ == "__main__":
+    unittest.main()

jleechanorg_pr_automation/tests/test_automation_marker_functions.py

@@ -0,0 +1,175 @@
+#!/usr/bin/env python3
+"""
+Unit tests for automation marker generation and parsing functions.
+
+Tests build_automation_marker() and parse_automation_marker() helper functions
+added to support enhanced automation markers with workflow:agent:commit format.
+"""
+
+import unittest
+
+from jleechanorg_pr_automation.codex_config import (
+    FIX_COMMENT_RUN_MARKER_PREFIX,
+    FIXPR_MARKER_PREFIX,
+    build_automation_marker,
+    parse_automation_marker,
+)
+
+
+class TestBuildAutomationMarker(unittest.TestCase):
+    """Test build_automation_marker() function"""
+
+    def test_basic_marker_generation(self):
+        """Test basic marker generation with all parameters"""
+        marker = build_automation_marker("fix-comment-run", "gemini", "abc1234")
+        expected = "<!-- fix-comment-run-automation-commit:gemini:abc1234-->"
+        self.assertEqual(marker, expected)
+
+    def test_fixpr_workflow(self):
+        """Test marker generation for fixpr workflow"""
+        marker = build_automation_marker("fixpr-run", "codex", "def5678")
+        expected = "<!-- fixpr-run-automation-commit:codex:def5678-->"
+        self.assertEqual(marker, expected)
+
+    def test_different_agents(self):
+        """Test marker generation with different agent names"""
+        agents = ["gemini", "codex", "claude"]
+        for agent in agents:
+            marker = build_automation_marker("fix-comment-run", agent, "sha123")
+            self.assertIn(f":{agent}:", marker)
+            self.assertTrue(marker.startswith("<!-- fix-comment-run-automation-commit:"))
+            self.assertTrue(marker.endswith("-->"))
+
+    def test_short_commit_sha(self):
+        """Test marker generation with short commit SHA"""
+        marker = build_automation_marker("fix-comment-run", "gemini", "abc")
+        expected = "<!-- fix-comment-run-automation-commit:gemini:abc-->"
+        self.assertEqual(marker, expected)
+
+    def test_long_commit_sha(self):
+        """Test marker generation with full 40-character commit SHA"""
+        full_sha = "a" * 40
+        marker = build_automation_marker("fix-comment-run", "gemini", full_sha)
+        expected = f"<!-- fix-comment-run-automation-commit:gemini:{full_sha}-->"
+        self.assertEqual(marker, expected)
+
+    def test_unknown_commit_fallback(self):
+        """Test marker generation with 'unknown' commit value"""
+        marker = build_automation_marker("fix-comment-run", "gemini", "unknown")
+        expected = "<!-- fix-comment-run-automation-commit:gemini:unknown-->"
+        self.assertEqual(marker, expected)
+
+    def test_marker_format_consistency(self):
+        """Test that marker format matches prefix constants"""
+        # Fix-comment marker should match FIX_COMMENT_RUN_MARKER_PREFIX
+        marker = build_automation_marker("fix-comment-run", "gemini", "abc123")
+        self.assertTrue(marker.startswith(FIX_COMMENT_RUN_MARKER_PREFIX))
+
+        # FixPR marker should match FIXPR_MARKER_PREFIX
+        marker = build_automation_marker("fixpr-run", "codex", "def456")
+        self.assertTrue(marker.startswith(FIXPR_MARKER_PREFIX))
+
+
+class TestParseAutomationMarker(unittest.TestCase):
+    """Test parse_automation_marker() function"""
+
+    def test_parse_new_format_with_agent(self):
+        """Test parsing new format marker with agent"""
+        marker = "<!-- fix-comment-run-automation-commit:gemini:abc123-->"
+        result = parse_automation_marker(marker)
+
+        self.assertIsNotNone(result)
+        self.assertEqual(result["workflow"], "fix-comment-run")
+        self.assertEqual(result["agent"], "gemini")
+        self.assertEqual(result["commit"], "abc123")
+
+    def test_parse_fixpr_marker(self):
+        """Test parsing fixpr-run marker"""
+        marker = "<!-- fixpr-run-automation-commit:codex:def456-->"
+        result = parse_automation_marker(marker)
+
+        self.assertIsNotNone(result)
+        self.assertEqual(result["workflow"], "fixpr-run")
+        self.assertEqual(result["agent"], "codex")
+        self.assertEqual(result["commit"], "def456")
+
+    def test_parse_legacy_format_without_agent(self):
+        """Test parsing legacy format marker without agent"""
+        marker = "<!-- fix-comment-automation-commit:abc123-->"
+        result = parse_automation_marker(marker)
+
+        self.assertIsNotNone(result)
+        self.assertEqual(result["workflow"], "fix-comment")
+        self.assertEqual(result["agent"], "unknown")
+        self.assertEqual(result["commit"], "abc123")
+
+    def test_parse_legacy_fixpr_marker(self):
+        """Test parsing legacy fixpr marker without agent"""
+        marker = "<!-- fixpr-automation-commit:ghi789-->"
+        result = parse_automation_marker(marker)
+
+        self.assertIsNotNone(result)
+        self.assertEqual(result["workflow"], "fixpr")
+        self.assertEqual(result["agent"], "unknown")
+        self.assertEqual(result["commit"], "ghi789")
+
+    def test_parse_invalid_marker_missing_html_comment(self):
+        """Test parsing invalid marker missing HTML comment markers"""
+        marker = "fix-comment-run-automation-commit:gemini:abc123"
+        result = parse_automation_marker(marker)
+        self.assertIsNone(result)
+
+    def test_parse_invalid_marker_wrong_format(self):
+        """Test parsing invalid marker with wrong format"""
+        marker = "<!-- some random comment -->"
+        result = parse_automation_marker(marker)
+        self.assertIsNone(result)
+
+    def test_parse_invalid_marker_too_many_colons(self):
+        """Test parsing marker with too many colons"""
+        marker = "<!-- fix-comment-run-automation-commit:gemini:abc123:extra-->"
+        result = parse_automation_marker(marker)
+        # Should return None for invalid format (3 colons instead of 2)
+        self.assertIsNone(result)
+
+    def test_parse_marker_with_whitespace(self):
+        """Test parsing marker with extra whitespace"""
+        marker = "<!-- fix-comment-run-automation-commit:gemini:abc123 -->"
+        result = parse_automation_marker(marker)
+
+        # Parser should handle trailing whitespace gracefully
+        self.assertIsNotNone(result)
+        self.assertEqual(result["workflow"], "fix-comment-run")
+
+    def test_roundtrip_consistency(self):
+        """Test that building and parsing a marker gives consistent results"""
+        workflow = "fix-comment-run"
+        agent = "gemini"
+        commit = "abc1234"
+
+        # Build marker
+        marker = build_automation_marker(workflow, agent, commit)
+
+        # Parse it back
+        result = parse_automation_marker(marker)
+
+        # Verify roundtrip consistency
+        self.assertIsNotNone(result)
+        self.assertEqual(result["workflow"], workflow)
+        self.assertEqual(result["agent"], agent)
+        self.assertEqual(result["commit"], commit)
+
+    def test_parse_with_different_workflows(self):
+        """Test parsing markers with different workflow types"""
+        workflows = ["fix-comment-run", "fixpr-run", "codex", "pr-automation"]
+
+        for workflow in workflows:
+            marker = build_automation_marker(workflow, "gemini", "abc123")
+            result = parse_automation_marker(marker)
+
+            self.assertIsNotNone(result)
+            self.assertEqual(result["workflow"], workflow)
+
+
+if __name__ == "__main__":
+    unittest.main()