test_metadata_exception.py 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317
  1. import unittest
  2. import time
  3. from unittest.mock import MagicMock, patch
  4. from core_types import (
  5. BizException,
  6. RateLimiteddError,
  7. RateLimitedError,
  8. SessionExpiredOrInvalidError,
  9. SessionExpiredError,
  10. PermissionDeniedError,
  11. NotFoundError,
  12. BizLogicError,
  13. NetworkTimeoutError,
  14. AccountStateError,
  15. AccountAuthError,
  16. AccountBannedError,
  17. AccountIncompleteError,
  18. AccountNotFoundError,
  19. PluginError,
  20. BookerStandaloneConfig,
  21. PluginConfig,
  22. normalize_error
  23. )
  24. from standalone import StandaloneGCO
  25. class TestMetadataExceptions(unittest.TestCase):
  26. def test_exception_pure_facts(self):
  27. """Verifies exception expresses pure domain facts without coupling scheduler policies."""
  28. # 1. RateLimiteddError
  29. err_rate = RateLimiteddError("Too fast")
  30. self.assertEqual(err_rate.code, 42901)
  31. self.assertEqual(err_rate.http_status, 429)
  32. self.assertEqual(err_rate.message, "Too fast")
  33. self.assertFalse(hasattr(err_rate, "lock_account"))
  34. self.assertFalse(hasattr(err_rate, "destroy_session"))
  35. self.assertFalse(hasattr(err_rate, "cooldown_sec"))
  36. self.assertFalse(hasattr(err_rate, "rotate_proxy"))
  37. # Semantic aliases verification
  38. self.assertIs(RateLimitedError, RateLimiteddError)
  39. self.assertIs(SessionExpiredError, SessionExpiredOrInvalidError)
  40. self.assertIs(PluginError, BizException)
  41. # 2. SessionExpiredOrInvalidError
  42. err_session = SessionExpiredOrInvalidError("Kicked out")
  43. self.assertEqual(err_session.code, 40101)
  44. self.assertEqual(err_session.http_status, 401)
  45. # 3. NetworkTimeoutError
  46. err_net = NetworkTimeoutError("Gateway timeout")
  47. self.assertEqual(err_net.code, 50401)
  48. self.assertEqual(err_net.http_status, 504)
  49. # 4. PermissionDeniedError
  50. err_perm = PermissionDeniedError("403 Forbidden")
  51. self.assertEqual(err_perm.code, 40301)
  52. self.assertEqual(err_perm.http_status, 403)
  53. # 5. AccountStateError subclasses
  54. auth_err = AccountAuthError("Bad credentials")
  55. self.assertEqual(auth_err.code, 40102)
  56. self.assertEqual(auth_err.http_status, 401)
  57. self.assertIsInstance(auth_err, AccountStateError)
  58. banned_err = AccountBannedError("Account banned")
  59. self.assertEqual(banned_err.code, 40302)
  60. self.assertEqual(banned_err.http_status, 403)
  61. self.assertIsInstance(banned_err, AccountStateError)
  62. incomplete_err = AccountIncompleteError("No applicant")
  63. self.assertEqual(incomplete_err.code, 42201)
  64. self.assertEqual(incomplete_err.http_status, 422)
  65. self.assertIsInstance(incomplete_err, AccountStateError)
  66. not_found_err = AccountNotFoundError("Account deleted")
  67. self.assertEqual(not_found_err.code, 40402)
  68. self.assertEqual(not_found_err.http_status, 404)
  69. self.assertIsInstance(not_found_err, AccountStateError)
  70. def test_normalize_error(self):
  71. # Already standardized exception
  72. rate_err = RateLimiteddError()
  73. self.assertIs(normalize_error(rate_err), rate_err)
  74. # Structured status code recognition (status_code / code)
  75. class MockHttpError(Exception):
  76. def __init__(self, status_code):
  77. self.status_code = status_code
  78. raw_429 = MockHttpError(429)
  79. normalized_429 = normalize_error(raw_429)
  80. self.assertIsInstance(normalized_429, RateLimiteddError)
  81. class MockCodeError(Exception):
  82. def __init__(self, code):
  83. self.code = code
  84. raw_sess = MockCodeError(40101)
  85. normalized_sess = normalize_error(raw_sess)
  86. self.assertIsInstance(normalized_sess, SessionExpiredOrInvalidError)
  87. # Account state fatal codes
  88. self.assertIsInstance(normalize_error(MockCodeError(40102)), AccountAuthError)
  89. self.assertIsInstance(normalize_error(MockCodeError(40302)), AccountBannedError)
  90. self.assertIsInstance(normalize_error(MockCodeError(42201)), AccountIncompleteError)
  91. self.assertIsInstance(normalize_error(MockCodeError(40402)), AccountNotFoundError)
  92. # Fallback for unknown exceptions
  93. raw_unknown = KeyError("element_not_found")
  94. normalized_unknown = normalize_error(raw_unknown)
  95. self.assertIsInstance(normalized_unknown, BizException)
  96. self.assertEqual(normalized_unknown.code, 50000)
  97. @patch("toolkit.cloud_api.CloudApi.Instance")
  98. def test_standalone_action_matrix_policy(self, mock_cloud_instance):
  99. mock_cloud = MagicMock()
  100. mock_cloud_instance.return_value = mock_cloud
  101. cfg = BookerStandaloneConfig(identifier="test_group")
  102. cfg.account.id = 12345
  103. cfg.account.username = "test_user"
  104. cfg.login_interval = 1200
  105. gco = StandaloneGCO(cfg=cfg, redis_conf={})
  106. mock_inst = MagicMock()
  107. gco.m_instance = mock_inst
  108. # Scenario A: 429 during login/session creation -> account throttled, lock account
  109. err = RateLimiteddError()
  110. gco._dispatch_error_policy("create_session", err)
  111. mock_cloud.lock_account.assert_called_once_with(12345, 1200)
  112. mock_inst.cleanup.assert_called_once()
  113. self.assertIsNone(gco.m_instance)
  114. # Scenario B: 429 during query -> session valid, egress IP throttled, never lock account, rotate IP
  115. mock_cloud.reset_mock()
  116. mock_inst2 = MagicMock()
  117. gco.m_instance = mock_inst2
  118. gco._dispatch_error_policy("query", err)
  119. mock_cloud.lock_account.assert_not_called()
  120. mock_inst2.cleanup.assert_called_once()
  121. self.assertIsNone(gco.m_instance)
  122. self.assertGreater(gco.m_next_query_time, time.time())
  123. # Scenario C: AccountAuthError -> permanently disable account, do not alert WeChat, do not retry soon
  124. mock_cloud.reset_mock()
  125. mock_inst3 = MagicMock()
  126. gco.m_instance = mock_inst3
  127. auth_err = AccountAuthError("Invalid credentials")
  128. gco._dispatch_error_policy("create_session", auth_err)
  129. mock_cloud._perform_request.assert_called_once()
  130. mock_cloud.push_weixin_text.assert_not_called()
  131. self.assertIsNone(gco.m_instance)
  132. def test_standalone_dispatch_session_expired_policy(self):
  133. cfg = BookerStandaloneConfig(identifier="test_group")
  134. gco = StandaloneGCO(cfg=cfg, redis_conf={})
  135. mock_inst = MagicMock()
  136. gco.m_instance = mock_inst
  137. # Trigger SessionExpiredOrInvalidError
  138. err = SessionExpiredOrInvalidError()
  139. gco._dispatch_error_policy("query", err)
  140. # Verify session destroyed and scheduled retry after 5s
  141. mock_inst.cleanup.assert_called_once()
  142. self.assertIsNone(gco.m_instance)
  143. self.assertGreater(gco.m_next_query_time, time.time())
  144. @patch("toolkit.cloud_api.CloudApi.Instance")
  145. def test_sentinel_error_dispatch(self, mock_cloud_instance):
  146. from sentinel import SentinelGCO
  147. from core_types import GroupConfig, Task
  148. mock_cloud = MagicMock()
  149. mock_cloud_instance.return_value = mock_cloud
  150. cfg = GroupConfig(identifier="test_sentinel")
  151. cfg.login_backoff = 1800
  152. cfg.proxy_cd = 300
  153. gco = SentinelGCO(cfg=cfg, redis_conf={})
  154. # Scenario 1: 429 during spawn -> account throttled, lock account
  155. plg_cfg = PluginConfig()
  156. plg_cfg.account.id = 999
  157. plg_cfg.account.username = "sentinel_user"
  158. gco._dispatch_error_policy("spawn", RateLimiteddError(), plg_cfg=plg_cfg)
  159. mock_cloud.lock_account.assert_called_once_with(999, 1800)
  160. self.assertGreater(gco.m_spawn_cooldown_until, time.time())
  161. # Scenario 2: 429 during query -> IP throttled, do not lock account, remove task to rotate proxy
  162. mock_cloud.reset_mock()
  163. mock_inst = MagicMock()
  164. mock_inst.config = plg_cfg
  165. task = Task(instance=mock_inst)
  166. gco.m_tasks.append(task)
  167. gco._dispatch_error_policy("query", RateLimiteddError(), task=task)
  168. mock_cloud.lock_account.assert_not_called()
  169. self.assertNotIn(task, gco.m_tasks)
  170. mock_inst.cleanup.assert_called_once()
  171. # Scenario 3: spawn triggers SessionExpiredOrInvalidError
  172. gco._dispatch_error_policy("spawn", SessionExpiredOrInvalidError(), plg_cfg=plg_cfg)
  173. self.assertGreater(gco.m_spawn_cooldown_until, 0)
  174. # Scenario 4: query triggers PermissionDeniedError
  175. mock_inst2 = MagicMock()
  176. mock_inst2.config = plg_cfg
  177. task2 = Task(instance=mock_inst2)
  178. gco.m_tasks.append(task2)
  179. gco._dispatch_error_policy("query", PermissionDeniedError(), task=task2)
  180. self.assertNotIn(task2, gco.m_tasks)
  181. # Scenario 5: spawn triggers PermissionDeniedError -> safely release account (lock=0) and cool down spawn
  182. mock_cloud.reset_mock()
  183. gco._dispatch_error_policy("spawn", PermissionDeniedError("Network Error (Fetch Failed / WAF Blocked)"), plg_cfg=plg_cfg)
  184. mock_cloud.lock_account.assert_called_once_with(999, 0)
  185. self.assertGreater(gco.m_spawn_cooldown_until, time.time())
  186. # Scenario 6: spawn triggers error with status_code=0 -> normalizes to PermissionDeniedError and safely releases account
  187. mock_cloud.reset_mock()
  188. class MockWafFetchError(Exception):
  189. status_code = 0
  190. gco._dispatch_error_policy("spawn", MockWafFetchError(), plg_cfg=plg_cfg)
  191. mock_cloud.lock_account.assert_called_once_with(999, 0)
  192. # Scenario 7: spawn triggers AccountBannedError -> disable in cloud, no WeChat alert, never release back with lock=0
  193. mock_cloud.reset_mock()
  194. gco._dispatch_error_policy("spawn", AccountBannedError("User banned"), plg_cfg=plg_cfg)
  195. mock_cloud._perform_request.assert_called_once()
  196. put_call_args = mock_cloud._perform_request.call_args
  197. self.assertEqual(put_call_args[0][0], "PUT")
  198. self.assertIn("/api/account/update", put_call_args[0][1])
  199. self.assertEqual(put_call_args[1]["json_data"]["status"], "disable")
  200. mock_cloud.push_weixin_text.assert_not_called()
  201. # Verify lock_account(..., 0) was NOT called
  202. mock_cloud.lock_account.assert_not_called()
  203. @patch("toolkit.cloud_api.CloudApi.Instance")
  204. def test_booker_error_dispatch(self, mock_cloud_instance):
  205. from booker import BuiltinBookerGCO, OrderBookerGCO
  206. from core_types import GroupConfig, Task
  207. mock_cloud = MagicMock()
  208. mock_cloud_instance.return_value = mock_cloud
  209. cfg = GroupConfig(identifier="test_booker")
  210. cfg.login_backoff = 900
  211. cfg.proxy_cd = 120
  212. gco = BuiltinBookerGCO(cfg=cfg, redis_conf={})
  213. mock_inst = MagicMock()
  214. mock_inst.config = None
  215. task = Task(instance=mock_inst)
  216. gco.m_tasks.append(task)
  217. # Scenario 1: booking triggers RateLimiteddError -> slot throttled, preserve account, remove task
  218. err = RateLimiteddError()
  219. gco._dispatch_error_policy("book", err, task=task)
  220. mock_cloud.lock_account.assert_not_called()
  221. self.assertNotIn(task, gco.m_tasks)
  222. mock_inst.cleanup.assert_called_once()
  223. # Scenario 2: spawn triggers RateLimiteddError -> account throttled, lock account
  224. mock_cloud.reset_mock()
  225. plg_cfg = PluginConfig()
  226. plg_cfg.account.id = 777
  227. plg_cfg.account.username = "booker_user"
  228. gco._dispatch_error_policy("spawn", RateLimiteddError(), plg_cfg=plg_cfg)
  229. mock_cloud.lock_account.assert_called_once_with(777, 900)
  230. self.assertGreater(gco.m_spawn_cooldown_until, time.time())
  231. # Scenario 3: spawn triggers PermissionDeniedError -> safely release account (lock=0)
  232. mock_cloud.reset_mock()
  233. gco._dispatch_error_policy("spawn", PermissionDeniedError("WAF Blocked"), plg_cfg=plg_cfg)
  234. mock_cloud.lock_account.assert_called_once_with(777, 0)
  235. self.assertGreater(gco.m_spawn_cooldown_until, time.time())
  236. # Scenario 4: Built-in Booker hits AccountAuthError -> permanently disable in cloud, no WeChat alert, never release with lock=0
  237. mock_cloud.reset_mock()
  238. gco._dispatch_error_policy("spawn", AccountAuthError("Invalid credentials"), plg_cfg=plg_cfg)
  239. mock_cloud._perform_request.assert_called_once()
  240. put_call_args = mock_cloud._perform_request.call_args
  241. self.assertEqual(put_call_args[0][0], "PUT")
  242. self.assertEqual(put_call_args[1]["json_data"]["status"], "disable")
  243. mock_cloud.push_weixin_text.assert_not_called()
  244. mock_cloud.lock_account.assert_not_called()
  245. # Scenario 5: Order Booker hits AccountIncompleteError -> mark VAS task failed, remove from tracker, no WeChat alert
  246. mock_cloud.reset_mock()
  247. order_gco = OrderBookerGCO(cfg=cfg, redis_conf={})
  248. order_gco.redis_client = MagicMock()
  249. order_plg_cfg = PluginConfig()
  250. order_plg_cfg.account.username = "order_user"
  251. order_plg_cfg.account.id = 0 # Order-provided account, not pool account
  252. order_task_id = 88888
  253. order_gco._dispatch_error_policy(
  254. "spawn",
  255. AccountIncompleteError("No applicant added"),
  256. plg_cfg=order_plg_cfg,
  257. task_id=order_task_id
  258. )
  259. mock_cloud.update_vas_task.assert_called_once_with("88888", {
  260. "status": "failed",
  261. "fail_reason": "Account fatal error: No applicant added (code=42201)"
  262. })
  263. order_gco.redis_client.zrem.assert_called_once_with(order_gco.m_tracker_key, order_task_id)
  264. mock_cloud.push_weixin_text.assert_not_called()
  265. if __name__ == "__main__":
  266. unittest.main()