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

jleechanorg_pr_automation/tests/test_automation_over_running_reproduction.py

@@ -8,13 +8,11 @@ This test reproduces the exact issue discovered:
 - No default manual override (should require explicit --manual_override)
 """
 
-import unittest
-import tempfile
-import os
-import shutil
 import argparse
-import json
-from datetime import datetime, timedelta
+import shutil
+import tempfile
+import unittest
+from datetime import datetime
 
 from jleechanorg_pr_automation.automation_safety_manager import AutomationSafetyManager
 
@@ -81,12 +79,12 @@ class TestAutomationOverRunningReproduction(unittest.TestCase):
         # Test that we can use --manual_override
         # Parse the new arguments
         parser = argparse.ArgumentParser()
-        parser.add_argument('--manual_override', type=str, help='Correct command')
+        parser.add_argument("--manual_override", type=str, help="Correct command")
 
         # The --manual_override command should work
-        args = parser.parse_args(['--manual_override', 'test@example.com'])
+        args = parser.parse_args(["--manual_override", "test@example.com"])
         self.assertIsNotNone(args.manual_override, "--manual_override command works")
-        self.assertEqual(args.manual_override, 'test@example.com')
+        self.assertEqual(args.manual_override, "test@example.com")
 
         # Test that --approve should no longer exist in the real CLI
         # (This test verifies our refactoring was successful)
@@ -124,7 +122,7 @@ class TestAutomationOverRunningReproduction(unittest.TestCase):
         This test documents the issue but doesn't enforce rate limiting yet.
         """
         # Document that rate limiting doesn't exist (future enhancement)
-        self.assertFalse(hasattr(self.manager, 'check_rate_limit'),
+        self.assertFalse(hasattr(self.manager, "check_rate_limit"),
                         "Rate limiting could be added as future enhancement")
 
         # Document the excessive rate that occurred (historical reference)
@@ -143,7 +141,7 @@ class TestAutomationOverRunningReproduction(unittest.TestCase):
                        "New limits (100 max) would have prevented 346 runs")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     print("🟢 GREEN PHASE: Running tests that now PASS after fixes")
     print("✅ Automation over-running issue RESOLVED")
     print("")

jleechanorg_pr_automation/tests/test_automation_safety_limits.py

@@ -3,19 +3,21 @@
 Test-Driven Development for PR Automation Safety Limits
 
 RED Phase: All tests should FAIL initially
-- PR attempt limits (max 5 per PR)
+- PR attempt limits (max 50 per PR - counts ALL attempts, not just failures)
 - Global run limits (max 50 total)
 - Manual approval requirement
+
+NEW BEHAVIOR: Counts ALL attempts (success + failure) against the limit.
 """
 
-import os
-import unittest
-import tempfile
 import json
+import os
 import shutil
+import tempfile
+import unittest
 from datetime import datetime, timedelta
 from pathlib import Path
-from unittest.mock import patch, MagicMock
+from unittest.mock import patch
 
 from jleechanorg_pr_automation.automation_safety_manager import AutomationSafetyManager
 
@@ -30,22 +32,22 @@ class TestAutomationSafetyLimits(unittest.TestCase):
         self.global_runs_file = os.path.join(self.test_dir, "global_runs.json")
         self.approval_file = os.path.join(self.test_dir, "manual_approval.json")
 
-        if hasattr(self, '_automation_manager'):
+        if hasattr(self, "_automation_manager"):
             del self._automation_manager
 
         # Initialize empty tracking files
-        with open(self.pr_attempts_file, 'w') as f:
+        with open(self.pr_attempts_file, "w") as f:
             json.dump({}, f)
-        with open(self.global_runs_file, 'w') as f:
+        with open(self.global_runs_file, "w") as f:
             json.dump({"total_runs": 0, "start_date": datetime.now().isoformat()}, f)
-        with open(self.approval_file, 'w') as f:
+        with open(self.approval_file, "w") as f:
             json.dump({"approved": False, "approval_date": None}, f)
 
     def tearDown(self):
         """Clean up test files"""
         shutil.rmtree(self.test_dir)
 
-    # Matrix 1: PR Attempt Limits (5 attempts per PR)
+    # Matrix 1: PR Attempt Limits (50 attempts per PR - counts ALL attempts)
     def test_pr_attempt_limit_1_should_allow(self):
         """RED: First attempt on PR #1001 should be allowed"""
         # This test will FAIL initially - no implementation exists
@@ -53,40 +55,48 @@ class TestAutomationSafetyLimits(unittest.TestCase):
         self.assertTrue(result)
         self.assertEqual(self.automation_manager.get_pr_attempts(1001), 0)
 
-    def test_pr_attempt_limit_5_should_allow(self):
-        """RED: 5th attempt on PR #1001 should be allowed"""
-        # Set up 4 previous attempts
-        self.automation_manager.record_pr_attempt(1001, "failure")
-        self.automation_manager.record_pr_attempt(1001, "failure")
-        self.automation_manager.record_pr_attempt(1001, "failure")
-        self.automation_manager.record_pr_attempt(1001, "failure")
+    def test_pr_attempt_limit_49_should_allow(self):
+        """RED: 49th attempt on PR #1001 should be allowed"""
+        # Set up 48 previous attempts (mix of success and failure - all count)
+        for i in range(48):
+            result_type = "success" if i % 2 == 0 else "failure"
+            self.automation_manager.record_pr_attempt(1001, result_type)
 
         result = self.automation_manager.can_process_pr(1001)
         self.assertTrue(result)
-        self.assertEqual(self.automation_manager.get_pr_attempts(1001), 4)
+        self.assertEqual(self.automation_manager.get_pr_attempts(1001), 48)
 
-    def test_pr_attempt_limit_6_should_block(self):
-        """RED: 6th attempt on PR #1001 should be blocked"""
-        # Set up 5 previous attempts (max limit reached)
-        for _ in range(5):
-            self.automation_manager.record_pr_attempt(1001, "failure")
+    def test_pr_attempt_limit_50_should_block(self):
+        """RED: 50th attempt on PR #1001 should be blocked (at limit)"""
+        # Set up 50 previous attempts (max limit reached - mix of success and failure)
+        for i in range(50):
+            result_type = "success" if i % 2 == 0 else "failure"
+            self.automation_manager.record_pr_attempt(1001, result_type)
 
         result = self.automation_manager.can_process_pr(1001)
         self.assertFalse(result)
-        self.assertEqual(self.automation_manager.get_pr_attempts(1001), 5)
+        self.assertEqual(self.automation_manager.get_pr_attempts(1001), 50)
 
-    def test_pr_attempt_success_resets_counter(self):
-        """RED: Successful PR attempt should reset counter"""
-        # Set up 3 failures then 1 success
-        self.automation_manager.record_pr_attempt(1001, "failure")
-        self.automation_manager.record_pr_attempt(1001, "failure")
-        self.automation_manager.record_pr_attempt(1001, "failure")
-        self.automation_manager.record_pr_attempt(1001, "success")
+    def test_pr_attempt_all_attempts_count(self):
+        """NEW BEHAVIOR: All attempts (success + failure) count toward limit"""
+        # Record 25 successes
+        for _ in range(25):
+            self.automation_manager.record_pr_attempt(1001, "success")
 
-        # Counter should reset, allowing new attempts
+        # Record 24 failures
+        for _ in range(24):
+            self.automation_manager.record_pr_attempt(1001, "failure")
+
+        # Total: 49 attempts - should still allow one more
         result = self.automation_manager.can_process_pr(1001)
         self.assertTrue(result)
-        self.assertEqual(self.automation_manager.get_pr_attempts(1001), 0)
+        self.assertEqual(self.automation_manager.get_pr_attempts(1001), 49)
+
+        # Record one more (50th) - should now be at limit
+        self.automation_manager.record_pr_attempt(1001, "success")
+        result = self.automation_manager.can_process_pr(1001)
+        self.assertFalse(result)
+        self.assertEqual(self.automation_manager.get_pr_attempts(1001), 50)
 
     # Matrix 2: Global Run Limits (50 total runs)
     def test_global_run_limit_1_should_allow(self):
@@ -150,18 +160,19 @@ class TestAutomationSafetyLimits(unittest.TestCase):
 
     # Matrix 4: Email Notification System
     @patch.dict(os.environ, {
-        'SMTP_SERVER': 'smtp.example.com',
-        'SMTP_PORT': '587',
-        'EMAIL_USER': 'test@example.com',
-        'EMAIL_PASS': 'testpass',
-        'EMAIL_TO': 'admin@example.com'
+        "SMTP_SERVER": "smtp.example.com",
+        "SMTP_PORT": "587",
+        "EMAIL_USER": "test@example.com",
+        "EMAIL_PASS": "testpass",
+        "EMAIL_TO": "admin@example.com"
     })
-    @patch('smtplib.SMTP')
+    @patch("smtplib.SMTP")
     def test_email_sent_when_pr_limit_reached(self, mock_smtp):
-        """RED: Email should be sent when PR reaches 5 attempts"""
-        # Set up 5 attempts to trigger notification
-        for _ in range(5):
-            self.automation_manager.record_pr_attempt(1001, "failure")
+        """RED: Email should be sent when PR reaches 50 attempts"""
+        # Set up 50 attempts to trigger notification (mix of success and failure)
+        for i in range(50):
+            result_type = "success" if i % 2 == 0 else "failure"
+            self.automation_manager.record_pr_attempt(1001, result_type)
 
         # Should trigger email
         self.automation_manager.check_and_notify_limits()
@@ -170,13 +181,13 @@ class TestAutomationSafetyLimits(unittest.TestCase):
         mock_smtp.assert_called_once()
 
     @patch.dict(os.environ, {
-        'SMTP_SERVER': 'smtp.example.com',
-        'SMTP_PORT': '587',
-        'EMAIL_USER': 'test@example.com',
-        'EMAIL_PASS': 'testpass',
-        'EMAIL_TO': 'admin@example.com'
+        "SMTP_SERVER": "smtp.example.com",
+        "SMTP_PORT": "587",
+        "EMAIL_USER": "test@example.com",
+        "EMAIL_PASS": "testpass",
+        "EMAIL_TO": "admin@example.com"
     })
-    @patch('smtplib.SMTP')
+    @patch("smtplib.SMTP")
     def test_email_sent_when_global_limit_reached(self, mock_smtp):
         """RED: Email should be sent when global limit of 50 is reached"""
         # Set up 50 runs to trigger notification
@@ -218,7 +229,6 @@ class TestAutomationSafetyLimits(unittest.TestCase):
     def test_concurrent_pr_attempts_thread_safe(self):
         """RED: Concurrent PR attempts should be thread-safe"""
         import threading
-        import time
 
         # Create a single manager instance explicitly for this test
         manager = AutomationSafetyManager(self.test_dir)
@@ -228,9 +238,9 @@ class TestAutomationSafetyLimits(unittest.TestCase):
             result = manager.try_process_pr(1001)
             results.append(result)
 
-        # Start 10 concurrent threads
+        # Start 55 concurrent threads (more than limit of 50)
         threads = []
-        for _ in range(10):
+        for _ in range(55):
             t = threading.Thread(target=attempt_pr)
             threads.append(t)
             t.start()
@@ -239,29 +249,31 @@ class TestAutomationSafetyLimits(unittest.TestCase):
         for t in threads:
             t.join()
 
-        # Should have exactly 5 successful attempts (limit)
+        # Should have exactly 50 successful attempts (limit)
         successful_attempts = sum(results)
-        self.assertEqual(successful_attempts, 5)
+        self.assertEqual(successful_attempts, 50)
 
     # Matrix 7: Configuration Management
-    def test_limits_configurable_via_environment(self):
-        """RED: Safety limits should be configurable via environment variables"""
-        with patch.dict(os.environ, {
-            'AUTOMATION_PR_LIMIT': '3',
-            'AUTOMATION_GLOBAL_LIMIT': '25'
-        }):
-            manager = AutomationSafetyManager(self.test_dir)
-
-            # Should use custom limits
-            self.assertEqual(manager.pr_limit, 3)
-            self.assertEqual(manager.global_limit, 25)
+    def test_limits_configurable_via_constructor_overrides(self):
+        """Safety limits should be configurable via explicit parameters (no env vars)."""
+        manager = AutomationSafetyManager(
+            self.test_dir,
+            limits={
+                "pr_limit": 3,
+                "global_limit": 25,
+            },
+        )
+
+        # Should use custom limits
+        self.assertEqual(manager.pr_limit, 3)
+        self.assertEqual(manager.global_limit, 25)
 
     def test_default_limits_when_no_config(self):
         """RED: Should use default limits when no configuration provided"""
         manager = AutomationSafetyManager(self.test_dir)
 
-        # Should use defaults
-        self.assertEqual(manager.pr_limit, 5)
+        # Should use defaults (pr_limit updated to 50)
+        self.assertEqual(manager.pr_limit, 50)
         self.assertEqual(manager.global_limit, 50)
 
     # Matrix 8: Daily Reset Functionality (50 runs per day)
@@ -307,23 +319,23 @@ class TestAutomationSafetyLimits(unittest.TestCase):
             "total_runs": 50,
             "start_date": datetime(2025, 9, 30, 12, 0, 0).isoformat()
         }
-        with open(self.global_runs_file, 'w') as f:
+        with open(self.global_runs_file, "w") as f:
             json.dump(legacy_data, f)
 
-        if hasattr(self, '_automation_manager'):
+        if hasattr(self, "_automation_manager"):
             del self._automation_manager
 
         # First run after upgrade should reset the stale counter
         self.assertTrue(self.automation_manager.can_start_global_run())
         self.assertEqual(self.automation_manager.get_global_runs(), 0)
 
-    @patch('jleechanorg_pr_automation.automation_safety_manager.datetime')
+    @patch("jleechanorg_pr_automation.automation_safety_manager.datetime")
     def test_daily_reset_new_day_resets_counter(self, mock_datetime):
         """RED: Counter should reset to 0 when a new day starts"""
         # Day 1: Record 50 runs
         day1 = datetime(2025, 10, 1, 10, 0, 0)
         mock_datetime.now.return_value = day1
-        mock_datetime.side_effect = lambda *args, **kw: datetime(*args, **kw)
+        mock_datetime.side_effect = datetime
 
         for _ in range(50):
             self.automation_manager.record_global_run()
@@ -341,10 +353,10 @@ class TestAutomationSafetyLimits(unittest.TestCase):
         self.assertTrue(result)
         self.assertEqual(self.automation_manager.get_global_runs(), 0)
 
-    @patch('jleechanorg_pr_automation.automation_safety_manager.datetime')
+    @patch("jleechanorg_pr_automation.automation_safety_manager.datetime")
     def test_daily_reset_multiple_days(self, mock_datetime):
         """RED: Counter should reset each day for multiple days"""
-        mock_datetime.side_effect = lambda *args, **kw: datetime(*args, **kw)
+        mock_datetime.side_effect = datetime
 
         # Day 1: 50 runs
         day1 = datetime(2025, 10, 1, 10, 0, 0)
@@ -366,10 +378,10 @@ class TestAutomationSafetyLimits(unittest.TestCase):
         mock_datetime.now.return_value = day3
         self.assertEqual(self.automation_manager.get_global_runs(), 0)
 
-    @patch('jleechanorg_pr_automation.automation_safety_manager.datetime')
+    @patch("jleechanorg_pr_automation.automation_safety_manager.datetime")
     def test_daily_reset_midnight_transition(self, mock_datetime):
         """RED: Counter should reset at midnight transition"""
-        mock_datetime.side_effect = lambda *args, **kw: datetime(*args, **kw)
+        mock_datetime.side_effect = datetime
 
         # 23:59:59 on Day 1 - at limit
         before_midnight = datetime(2025, 10, 1, 23, 59, 59)
@@ -390,7 +402,7 @@ class TestAutomationSafetyLimits(unittest.TestCase):
     def automation_manager(self):
         """RED: This property will fail - no AutomationSafetyManager exists yet"""
         # This will fail until we implement the class in GREEN phase
-        if not hasattr(self, '_automation_manager'):
+        if not hasattr(self, "_automation_manager"):
             self._automation_manager = AutomationSafetyManager(self.test_dir)
         return self._automation_manager
 
@@ -425,7 +437,7 @@ class TestAutomationIntegration(unittest.TestCase):
     def test_shell_script_respects_safety_limits(self):
         """RED: Shell script should check safety limits before processing"""
         # This test will fail - existing script doesn't have safety checks
-        with patch('subprocess.run') as mock_run:
+        with patch("subprocess.run") as mock_run:
             mock_run.return_value.returncode = 1  # Safety limit hit
 
             result = self.run_automation_script()
@@ -446,7 +458,7 @@ class TestAutomationIntegration(unittest.TestCase):
         import subprocess
         return subprocess.run([
             "/Users/jleechan/projects/worktree_worker2/automation/simple_pr_batch.sh"
-        ], capture_output=True, text=True)
+        ], check=False, capture_output=True, text=True)
 
     def read_launchd_plist(self):
         """Helper to read launchd plist file"""
@@ -455,7 +467,7 @@ class TestAutomationIntegration(unittest.TestCase):
             return f.read()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # RED Phase: Run tests to confirm they FAIL
     print("🔴 RED Phase: Running failing tests for automation safety limits")
     print("Expected: ALL TESTS SHOULD FAIL (no implementation exists)")

jleechanorg_pr_automation/tests/test_automation_safety_manager_comprehensive.py

@@ -4,15 +4,14 @@ Comprehensive test suite for AutomationSafetyManager
 Using TDD methodology with 150+ test cases covering all safety logic
 """
 
-import pytest
 import json
-import tempfile
 import os
+import tempfile
 import threading
-import time
-from pathlib import Path
 from datetime import datetime, timedelta
-from unittest.mock import Mock, patch, MagicMock
+from unittest.mock import Mock, patch
+
+import pytest
 
 # Import the automation safety manager using proper Python module path
 from jleechanorg_pr_automation.automation_safety_manager import AutomationSafetyManager
@@ -47,7 +46,7 @@ class TestAutomationSafetyManagerInit:
                 "pr_limit": 3,
                 "daily_limit": 100
             }
-            with open(config_file, 'w') as f:
+            with open(config_file, "w") as f:
                 json.dump(config_data, f)
 
             manager = AutomationSafetyManager(temp_dir)
@@ -62,7 +61,7 @@ class TestAutomationSafetyManagerInit:
             config_file = os.path.join(temp_dir, "automation_safety_config.json")
             assert os.path.exists(config_file)
 
-            with open(config_file, 'r') as f:
+            with open(config_file) as f:
                 config = json.load(f)
             assert "global_limit" in config
             assert "pr_limit" in config
@@ -72,7 +71,7 @@ class TestAutomationSafetyManagerInit:
         with tempfile.TemporaryDirectory() as temp_dir:
             # Create invalid config file
             config_file = os.path.join(temp_dir, "automation_safety_config.json")
-            with open(config_file, 'w') as f:
+            with open(config_file, "w") as f:
                 f.write("{ invalid json")
 
             manager = AutomationSafetyManager(temp_dir)
@@ -224,12 +223,12 @@ class TestPRLimits:
         assert manager.can_process_pr(pr_key) == True
 
     def test_can_process_pr_at_limit(self, manager):
-        """Test PR processing denied when at limit"""
+        """Test PR processing denied when at failure limit"""
         pr_key = "test-repo-123"
 
-        # Process PR up to limit
+        # Record failures up to limit
         for _ in range(manager.pr_limit):
-            manager.record_pr_attempt(pr_key, "success")
+            manager.record_pr_attempt(pr_key, "failure")
 
         assert manager.can_process_pr(pr_key) == False
 
@@ -337,11 +336,11 @@ class TestEmailNotifications:
             yield AutomationSafetyManager(temp_dir)
 
     @patch.dict(os.environ, {
-        'SMTP_SERVER': 'smtp.example.com',
-        'SMTP_PORT': '587',
-        'EMAIL_USER': 'test@example.com',
-        'EMAIL_PASS': 'password',
-        'EMAIL_TO': 'admin@example.com'
+        "SMTP_SERVER": "smtp.example.com",
+        "SMTP_PORT": "587",
+        "EMAIL_USER": "test@example.com",
+        "EMAIL_PASS": "password",
+        "EMAIL_TO": "admin@example.com"
     })
     def test_email_config_complete(self, manager):
         """Test email configuration detection when complete"""
@@ -353,8 +352,8 @@ class TestEmailNotifications:
         assert manager._is_email_configured() == False
 
     @patch.dict(os.environ, {
-        'SMTP_SERVER': 'smtp.example.com',
-        'EMAIL_USER': 'test@example.com'
+        "SMTP_SERVER": "smtp.example.com",
+        "EMAIL_USER": "test@example.com"
         # Missing SMTP_PORT, EMAIL_PASS, EMAIL_TO
     })
     def test_email_config_partial(self, manager):
@@ -362,13 +361,13 @@ class TestEmailNotifications:
         assert manager._is_email_configured() == False
 
     @patch.dict(os.environ, {
-        'SMTP_SERVER': 'smtp.example.com',
-        'SMTP_PORT': '587',
-        'EMAIL_USER': 'test@example.com',
-        'EMAIL_PASS': 'password',
-        'EMAIL_TO': 'admin@example.com'
+        "SMTP_SERVER": "smtp.example.com",
+        "SMTP_PORT": "587",
+        "EMAIL_USER": "test@example.com",
+        "EMAIL_PASS": "password",
+        "EMAIL_TO": "admin@example.com"
     })
-    @patch('smtplib.SMTP')
+    @patch("smtplib.SMTP")
     def test_send_notification_success(self, mock_smtp, manager):
         """Test successful email notification sending"""
         mock_server = Mock()
@@ -377,54 +376,54 @@ class TestEmailNotifications:
         result = manager.send_notification("Test Subject", "Test message")
 
         assert result == True
-        mock_smtp.assert_called_once_with('smtp.example.com', 587)
+        mock_smtp.assert_called_once_with("smtp.example.com", 587)
         mock_server.starttls.assert_called_once()
-        mock_server.login.assert_called_once_with('test@example.com', 'password')
+        mock_server.login.assert_called_once_with("test@example.com", "password")
         mock_server.send_message.assert_called_once()
         mock_server.quit.assert_called_once()
 
     @patch.dict(os.environ, {}, clear=True)
     def test_send_notification_no_config(self, manager):
         """Test email notification when not configured"""
-        with patch.object(manager.logger, 'info') as mock_info:
+        with patch.object(manager.logger, "info") as mock_info:
             result = manager.send_notification("Test", "Message")
 
             assert result == False
             mock_info.assert_called_with("Email configuration incomplete - skipping notification")
 
     @patch.dict(os.environ, {
-        'SMTP_SERVER': 'smtp.example.com',
-        'SMTP_PORT': '587',
-        'EMAIL_USER': 'test@example.com',
-        'EMAIL_PASS': 'password',
-        'EMAIL_TO': 'admin@example.com'
+        "SMTP_SERVER": "smtp.example.com",
+        "SMTP_PORT": "587",
+        "EMAIL_USER": "test@example.com",
+        "EMAIL_PASS": "password",
+        "EMAIL_TO": "admin@example.com"
     })
-    @patch('smtplib.SMTP')
+    @patch("smtplib.SMTP")
     def test_send_notification_smtp_error(self, mock_smtp, manager):
         """Test email notification with SMTP error"""
         mock_smtp.side_effect = Exception("SMTP connection failed")
 
-        with patch.object(manager.logger, 'error') as mock_error:
+        with patch.object(manager.logger, "error") as mock_error:
             result = manager.send_notification("Test", "Message")
 
             assert result == False
             mock_error.assert_called()
 
     @patch.dict(os.environ, {
-        'SMTP_SERVER': 'smtp.example.com',
-        'SMTP_PORT': '587',
-        'EMAIL_USER': 'test@example.com',
-        'EMAIL_PASS': 'password',
-        'EMAIL_TO': 'admin@example.com'
+        "SMTP_SERVER": "smtp.example.com",
+        "SMTP_PORT": "587",
+        "EMAIL_USER": "test@example.com",
+        "EMAIL_PASS": "password",
+        "EMAIL_TO": "admin@example.com"
     })
-    @patch('smtplib.SMTP')
+    @patch("smtplib.SMTP")
     def test_send_notification_login_error(self, mock_smtp, manager):
         """Test email notification with login error"""
         mock_server = Mock()
         mock_server.login.side_effect = Exception("Authentication failed")
         mock_smtp.return_value = mock_server
 
-        with patch.object(manager.logger, 'error') as mock_error:
+        with patch.object(manager.logger, "error") as mock_error:
             result = manager.send_notification("Test", "Message")
 
             assert result == False
@@ -493,7 +492,7 @@ class TestFileLocking:
         global_runs_file = os.path.join(manager.data_dir, "global_runs.json")
         manager.record_global_run()  # Create the file first
 
-        with open(global_runs_file, 'w') as f:
+        with open(global_runs_file, "w") as f:
             f.write("{ corrupted json")
 
         # Should recover gracefully
@@ -502,8 +501,8 @@ class TestFileLocking:
 
     def test_permission_error_handling(self, manager):
         """Test handling of file permission errors"""
-        with patch('jleechanorg_pr_automation.utils.json_manager.write_json', return_value=False):
-            with patch.object(manager.logger, 'error') as mock_error:
+        with patch("jleechanorg_pr_automation.utils.json_manager.write_json", return_value=False):
+            with patch.object(manager.logger, "error") as mock_error:
                 # Should not raise exception
                 manager.record_global_run()
                 mock_error.assert_called()
@@ -523,7 +522,7 @@ class TestConfigurationManagement:
                 "email_notifications": True,
                 "max_pr_size": 1000
             }
-            with open(config_file, 'w') as f:
+            with open(config_file, "w") as f:
                 json.dump(config_data, f)
 
             manager = AutomationSafetyManager(temp_dir)
@@ -538,7 +537,7 @@ class TestConfigurationManagement:
                 "global_limit": 15
                 # Missing other settings
             }
-            with open(config_file, 'w') as f:
+            with open(config_file, "w") as f:
                 json.dump(config_data, f)
 
             manager = AutomationSafetyManager(temp_dir)
@@ -553,7 +552,7 @@ class TestConfigurationManagement:
             config_file = os.path.join(temp_dir, "automation_safety_config.json")
             assert os.path.exists(config_file)
 
-            with open(config_file, 'r') as f:
+            with open(config_file) as f:
                 config = json.load(f)
             assert "global_limit" in config
             assert "pr_limit" in config
@@ -599,13 +598,13 @@ class TestIntegrationScenarios:
             assert attempts[0]["result"] == "success"
 
     def test_hitting_pr_limits(self, manager):
-        """Test behavior when hitting PR limits"""
+        """Test behavior when hitting PR failure limits"""
         pr_key = "test-repo-limit"
 
-        # Process up to limit
+        # Fail up to limit
         for i in range(manager.pr_limit):
             assert manager.can_process_pr(pr_key) == True
-            manager.record_pr_attempt(pr_key, "success")
+            manager.record_pr_attempt(pr_key, "failure")
 
         # Should now be at limit
         assert manager.can_process_pr(pr_key) == False
@@ -631,7 +630,8 @@ class TestIntegrationScenarios:
                 manager.record_pr_attempt(pr_key, result)
 
         attempts = manager.get_pr_attempt_list(pr_key)
-        assert len(attempts) <= manager.pr_limit
+        # Attempt history should remain bounded: failures + most recent non-failure
+        assert len(attempts) <= manager.pr_limit + 1
 
         # Verify results are recorded correctly
         recorded_results = [attempt["result"] for attempt in attempts]
@@ -655,5 +655,5 @@ class TestIntegrationScenarios:
         assert len(attempts1) == len(attempts2)
 
 
-if __name__ == '__main__':
-    pytest.main([__file__, '-v', '--tb=short'])
+if __name__ == "__main__":
+    pytest.main([__file__, "-v", "--tb=short"])

jleechanorg_pr_automation/tests/test_codex_actor_matching.py

@@ -10,7 +10,7 @@ class TestCodexActorMatching(unittest.TestCase):
     """Validate detection of Codex-authored commits."""
 
     def setUp(self) -> None:
-        self.monitor = JleechanorgPRMonitor()
+        self.monitor = JleechanorgPRMonitor(automation_username="test-automation-user")
 
     def test_detects_codex_via_actor_fields(self) -> None:
         commit_details = {