import unittest import time from unittest.mock import MagicMock, patch from core_types import ( BizException, RateLimiteddError, RateLimitedError, SessionExpiredOrInvalidError, SessionExpiredError, PermissionDeniedError, NotFoundError, BizLogicError, NetworkTimeoutError, AccountStateError, AccountAuthError, AccountBannedError, AccountIncompleteError, AccountNotFoundError, PluginError, BookerStandaloneConfig, PluginConfig, normalize_error ) from standalone import StandaloneGCO class TestMetadataExceptions(unittest.TestCase): def test_exception_pure_facts(self): """Verifies exception expresses pure domain facts without coupling scheduler policies.""" # 1. RateLimiteddError err_rate = RateLimiteddError("Too fast") self.assertEqual(err_rate.code, 42901) self.assertEqual(err_rate.http_status, 429) self.assertEqual(err_rate.message, "Too fast") self.assertFalse(hasattr(err_rate, "lock_account")) self.assertFalse(hasattr(err_rate, "destroy_session")) self.assertFalse(hasattr(err_rate, "cooldown_sec")) self.assertFalse(hasattr(err_rate, "rotate_proxy")) # Semantic aliases verification self.assertIs(RateLimitedError, RateLimiteddError) self.assertIs(SessionExpiredError, SessionExpiredOrInvalidError) self.assertIs(PluginError, BizException) # 2. SessionExpiredOrInvalidError err_session = SessionExpiredOrInvalidError("Kicked out") self.assertEqual(err_session.code, 40101) self.assertEqual(err_session.http_status, 401) # 3. NetworkTimeoutError err_net = NetworkTimeoutError("Gateway timeout") self.assertEqual(err_net.code, 50401) self.assertEqual(err_net.http_status, 504) # 4. PermissionDeniedError err_perm = PermissionDeniedError("403 Forbidden") self.assertEqual(err_perm.code, 40301) self.assertEqual(err_perm.http_status, 403) # 5. AccountStateError subclasses auth_err = AccountAuthError("Bad credentials") self.assertEqual(auth_err.code, 40102) self.assertEqual(auth_err.http_status, 401) self.assertIsInstance(auth_err, AccountStateError) banned_err = AccountBannedError("Account banned") self.assertEqual(banned_err.code, 40302) self.assertEqual(banned_err.http_status, 403) self.assertIsInstance(banned_err, AccountStateError) incomplete_err = AccountIncompleteError("No applicant") self.assertEqual(incomplete_err.code, 42201) self.assertEqual(incomplete_err.http_status, 422) self.assertIsInstance(incomplete_err, AccountStateError) not_found_err = AccountNotFoundError("Account deleted") self.assertEqual(not_found_err.code, 40402) self.assertEqual(not_found_err.http_status, 404) self.assertIsInstance(not_found_err, AccountStateError) def test_normalize_error(self): # Already standardized exception rate_err = RateLimiteddError() self.assertIs(normalize_error(rate_err), rate_err) # Structured status code recognition (status_code / code) class MockHttpError(Exception): def __init__(self, status_code): self.status_code = status_code raw_429 = MockHttpError(429) normalized_429 = normalize_error(raw_429) self.assertIsInstance(normalized_429, RateLimiteddError) class MockCodeError(Exception): def __init__(self, code): self.code = code raw_sess = MockCodeError(40101) normalized_sess = normalize_error(raw_sess) self.assertIsInstance(normalized_sess, SessionExpiredOrInvalidError) # Account state fatal codes self.assertIsInstance(normalize_error(MockCodeError(40102)), AccountAuthError) self.assertIsInstance(normalize_error(MockCodeError(40302)), AccountBannedError) self.assertIsInstance(normalize_error(MockCodeError(42201)), AccountIncompleteError) self.assertIsInstance(normalize_error(MockCodeError(40402)), AccountNotFoundError) # Fallback for unknown exceptions raw_unknown = KeyError("element_not_found") normalized_unknown = normalize_error(raw_unknown) self.assertIsInstance(normalized_unknown, BizException) self.assertEqual(normalized_unknown.code, 50000) @patch("toolkit.cloud_api.CloudApi.Instance") def test_standalone_action_matrix_policy(self, mock_cloud_instance): mock_cloud = MagicMock() mock_cloud_instance.return_value = mock_cloud cfg = BookerStandaloneConfig(identifier="test_group") cfg.account.id = 12345 cfg.account.username = "test_user" cfg.login_interval = 1200 gco = StandaloneGCO(cfg=cfg, redis_conf={}) mock_inst = MagicMock() gco.m_instance = mock_inst # Scenario A: 429 during login/session creation -> account throttled, lock account err = RateLimiteddError() gco._dispatch_error_policy("create_session", err) mock_cloud.lock_account.assert_called_once_with(12345, 1200) mock_inst.cleanup.assert_called_once() self.assertIsNone(gco.m_instance) # Scenario B: 429 during query -> session valid, egress IP throttled, never lock account, rotate IP mock_cloud.reset_mock() mock_inst2 = MagicMock() gco.m_instance = mock_inst2 gco._dispatch_error_policy("query", err) mock_cloud.lock_account.assert_not_called() mock_inst2.cleanup.assert_called_once() self.assertIsNone(gco.m_instance) self.assertGreater(gco.m_next_query_time, time.time()) # Scenario C: AccountAuthError -> permanently disable account, do not alert WeChat, do not retry soon mock_cloud.reset_mock() mock_inst3 = MagicMock() gco.m_instance = mock_inst3 auth_err = AccountAuthError("Invalid credentials") gco._dispatch_error_policy("create_session", auth_err) mock_cloud._perform_request.assert_called_once() mock_cloud.push_weixin_text.assert_not_called() self.assertIsNone(gco.m_instance) def test_standalone_dispatch_session_expired_policy(self): cfg = BookerStandaloneConfig(identifier="test_group") gco = StandaloneGCO(cfg=cfg, redis_conf={}) mock_inst = MagicMock() gco.m_instance = mock_inst # Trigger SessionExpiredOrInvalidError err = SessionExpiredOrInvalidError() gco._dispatch_error_policy("query", err) # Verify session destroyed and scheduled retry after 5s mock_inst.cleanup.assert_called_once() self.assertIsNone(gco.m_instance) self.assertGreater(gco.m_next_query_time, time.time()) @patch("toolkit.cloud_api.CloudApi.Instance") def test_sentinel_error_dispatch(self, mock_cloud_instance): from sentinel import SentinelGCO from core_types import GroupConfig, Task mock_cloud = MagicMock() mock_cloud_instance.return_value = mock_cloud cfg = GroupConfig(identifier="test_sentinel") cfg.login_backoff = 1800 cfg.proxy_cd = 300 gco = SentinelGCO(cfg=cfg, redis_conf={}) # Scenario 1: 429 during spawn -> account throttled, lock account plg_cfg = PluginConfig() plg_cfg.account.id = 999 plg_cfg.account.username = "sentinel_user" gco._dispatch_error_policy("spawn", RateLimiteddError(), plg_cfg=plg_cfg) mock_cloud.lock_account.assert_called_once_with(999, 1800) self.assertGreater(gco.m_spawn_cooldown_until, time.time()) # Scenario 2: 429 during query -> IP throttled, do not lock account, remove task to rotate proxy mock_cloud.reset_mock() mock_inst = MagicMock() mock_inst.config = plg_cfg task = Task(instance=mock_inst) gco.m_tasks.append(task) gco._dispatch_error_policy("query", RateLimiteddError(), task=task) mock_cloud.lock_account.assert_not_called() self.assertNotIn(task, gco.m_tasks) mock_inst.cleanup.assert_called_once() # Scenario 3: spawn triggers SessionExpiredOrInvalidError gco._dispatch_error_policy("spawn", SessionExpiredOrInvalidError(), plg_cfg=plg_cfg) self.assertGreater(gco.m_spawn_cooldown_until, 0) # Scenario 4: query triggers PermissionDeniedError mock_inst2 = MagicMock() mock_inst2.config = plg_cfg task2 = Task(instance=mock_inst2) gco.m_tasks.append(task2) gco._dispatch_error_policy("query", PermissionDeniedError(), task=task2) self.assertNotIn(task2, gco.m_tasks) # Scenario 5: spawn triggers PermissionDeniedError -> safely release account (lock=0) and cool down spawn mock_cloud.reset_mock() gco._dispatch_error_policy("spawn", PermissionDeniedError("Network Error (Fetch Failed / WAF Blocked)"), plg_cfg=plg_cfg) mock_cloud.lock_account.assert_called_once_with(999, 0) self.assertGreater(gco.m_spawn_cooldown_until, time.time()) # Scenario 6: spawn triggers error with status_code=0 -> normalizes to PermissionDeniedError and safely releases account mock_cloud.reset_mock() class MockWafFetchError(Exception): status_code = 0 gco._dispatch_error_policy("spawn", MockWafFetchError(), plg_cfg=plg_cfg) mock_cloud.lock_account.assert_called_once_with(999, 0) # Scenario 7: spawn triggers AccountBannedError -> disable in cloud, no WeChat alert, never release back with lock=0 mock_cloud.reset_mock() gco._dispatch_error_policy("spawn", AccountBannedError("User banned"), plg_cfg=plg_cfg) mock_cloud._perform_request.assert_called_once() put_call_args = mock_cloud._perform_request.call_args self.assertEqual(put_call_args[0][0], "PUT") self.assertIn("/api/account/update", put_call_args[0][1]) self.assertEqual(put_call_args[1]["json_data"]["status"], "disable") mock_cloud.push_weixin_text.assert_not_called() # Verify lock_account(..., 0) was NOT called mock_cloud.lock_account.assert_not_called() @patch("toolkit.cloud_api.CloudApi.Instance") def test_booker_error_dispatch(self, mock_cloud_instance): from booker import BuiltinBookerGCO, OrderBookerGCO from core_types import GroupConfig, Task mock_cloud = MagicMock() mock_cloud_instance.return_value = mock_cloud cfg = GroupConfig(identifier="test_booker") cfg.login_backoff = 900 cfg.proxy_cd = 120 gco = BuiltinBookerGCO(cfg=cfg, redis_conf={}) mock_inst = MagicMock() mock_inst.config = None task = Task(instance=mock_inst) gco.m_tasks.append(task) # Scenario 1: booking triggers RateLimiteddError -> slot throttled, preserve account, remove task err = RateLimiteddError() gco._dispatch_error_policy("book", err, task=task) mock_cloud.lock_account.assert_not_called() self.assertNotIn(task, gco.m_tasks) mock_inst.cleanup.assert_called_once() # Scenario 2: spawn triggers RateLimiteddError -> account throttled, lock account mock_cloud.reset_mock() plg_cfg = PluginConfig() plg_cfg.account.id = 777 plg_cfg.account.username = "booker_user" gco._dispatch_error_policy("spawn", RateLimiteddError(), plg_cfg=plg_cfg) mock_cloud.lock_account.assert_called_once_with(777, 900) self.assertGreater(gco.m_spawn_cooldown_until, time.time()) # Scenario 3: spawn triggers PermissionDeniedError -> safely release account (lock=0) mock_cloud.reset_mock() gco._dispatch_error_policy("spawn", PermissionDeniedError("WAF Blocked"), plg_cfg=plg_cfg) mock_cloud.lock_account.assert_called_once_with(777, 0) self.assertGreater(gco.m_spawn_cooldown_until, time.time()) # Scenario 4: Built-in Booker hits AccountAuthError -> permanently disable in cloud, no WeChat alert, never release with lock=0 mock_cloud.reset_mock() gco._dispatch_error_policy("spawn", AccountAuthError("Invalid credentials"), plg_cfg=plg_cfg) mock_cloud._perform_request.assert_called_once() put_call_args = mock_cloud._perform_request.call_args self.assertEqual(put_call_args[0][0], "PUT") self.assertEqual(put_call_args[1]["json_data"]["status"], "disable") mock_cloud.push_weixin_text.assert_not_called() mock_cloud.lock_account.assert_not_called() # Scenario 5: Order Booker hits AccountIncompleteError -> mark VAS task failed, remove from tracker, no WeChat alert mock_cloud.reset_mock() order_gco = OrderBookerGCO(cfg=cfg, redis_conf={}) order_gco.redis_client = MagicMock() order_plg_cfg = PluginConfig() order_plg_cfg.account.username = "order_user" order_plg_cfg.account.id = 0 # Order-provided account, not pool account order_task_id = 88888 order_gco._dispatch_error_policy( "spawn", AccountIncompleteError("No applicant added"), plg_cfg=order_plg_cfg, task_id=order_task_id ) mock_cloud.update_vas_task.assert_called_once_with("88888", { "status": "failed", "fail_reason": "Account fatal error: No applicant added (code=42201)" }) order_gco.redis_client.zrem.assert_called_once_with(order_gco.m_tracker_key, order_task_id) mock_cloud.push_weixin_text.assert_not_called() if __name__ == "__main__": unittest.main()