| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317 |
- 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()
|