test_vas_task_pause_guards.py 7.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211
  1. import unittest
  2. from unittest.mock import AsyncMock, MagicMock, patch
  3. from datetime import datetime
  4. from app.models.vas_task import VasTask
  5. from app.models.order import VasOrder
  6. from app.models.product_routing import VasProductRouting
  7. from app.schemas.order import VasOrderPatchUserInputs
  8. from app.core.biz_exception import BizLogicError
  9. from app.services.order_service import OrderService
  10. from app.services.webhook_service import WebhookService
  11. from app.services.vas_task_service import VasTaskService
  12. class TestVasTaskPauseGuards(unittest.IsolatedAsyncioTestCase):
  13. async def test_order_cancel_cancels_paused_task(self):
  14. db = AsyncMock()
  15. order = VasOrder(
  16. id="ORD-001",
  17. status="paid",
  18. product_id=1,
  19. user_inputs={}
  20. )
  21. paused_task = VasTask(
  22. id=10,
  23. order_id="ORD-001",
  24. routing_key="test.routing",
  25. status="pause"
  26. )
  27. order_mock = MagicMock()
  28. order_mock.scalar_one_or_none.return_value = order
  29. tasks_mock = MagicMock()
  30. tasks_mock.scalars.return_value.all.return_value = [paused_task]
  31. db.execute.side_effect = [order_mock, tasks_mock]
  32. cancelled_order = await OrderService.cancel(db, "ORD-001")
  33. self.assertEqual(cancelled_order.status, "closed")
  34. self.assertEqual(paused_task.status, "cancelled")
  35. db.commit.assert_awaited()
  36. async def test_order_patch_user_inputs_cancels_paused_task(self):
  37. db = AsyncMock()
  38. order = VasOrder(
  39. id="ORD-002",
  40. status="paid",
  41. product_id=1,
  42. user_inputs={"name": "Old"}
  43. )
  44. paused_task = VasTask(
  45. id=20,
  46. order_id="ORD-002",
  47. routing_key="test.routing",
  48. status="pause"
  49. )
  50. order_mock = MagicMock()
  51. order_mock.scalar_one_or_none.return_value = order
  52. tasks_mock = MagicMock()
  53. tasks_mock.scalars.return_value.all.return_value = [paused_task]
  54. db.execute.side_effect = [order_mock, tasks_mock]
  55. with patch.object(WebhookService, "_create_task_if_not_exists", new_callable=AsyncMock) as mock_create:
  56. payload = VasOrderPatchUserInputs(user_inputs={"name": "New"})
  57. patched_order = await OrderService.patch_user_inputs(db, "ORD-002", payload)
  58. self.assertEqual(paused_task.status, "cancelled")
  59. self.assertEqual(patched_order.user_inputs, {"name": "New"})
  60. mock_create.assert_awaited_once_with(db, order)
  61. async def test_webhook_create_task_skips_if_paused_task_exists(self):
  62. db = AsyncMock()
  63. order = VasOrder(
  64. id="ORD-003",
  65. product_id=1,
  66. status="paid",
  67. user_inputs={"email": "test@example.com"}
  68. )
  69. routing = VasProductRouting(
  70. id=1,
  71. product_id=1,
  72. routing_key="test.routing",
  73. is_active=1,
  74. priority=10,
  75. script_version="v1"
  76. )
  77. paused_task = VasTask(
  78. id=30,
  79. order_id="ORD-003",
  80. routing_key="test.routing",
  81. status="pause"
  82. )
  83. routings_mock = MagicMock()
  84. routings_mock.scalars.return_value.all.return_value = [routing]
  85. exists_mock = MagicMock()
  86. exists_mock.scalar_one_or_none.return_value = paused_task
  87. db.execute.side_effect = [routings_mock, exists_mock]
  88. created = await WebhookService._create_task_if_not_exists(db, order)
  89. # Should skip creation since paused task exists
  90. self.assertEqual(created, [])
  91. db.add.assert_not_called()
  92. async def test_pause_rejects_completed_or_cancelled_task(self):
  93. db = AsyncMock()
  94. completed_task = VasTask(id=1, status="completed", order_id="ORD-01")
  95. mock_res1 = MagicMock()
  96. mock_res1.scalar_one_or_none.return_value = completed_task
  97. db.execute.return_value = mock_res1
  98. with self.assertRaises(BizLogicError) as ctx1:
  99. await VasTaskService.pause(db, 1)
  100. self.assertIn("Cannot pause a completed task", str(ctx1.exception))
  101. cancelled_task = VasTask(id=2, status="cancelled", order_id="ORD-02")
  102. mock_res2 = MagicMock()
  103. mock_res2.scalar_one_or_none.return_value = cancelled_task
  104. db.execute.return_value = mock_res2
  105. with self.assertRaises(BizLogicError) as ctx2:
  106. await VasTaskService.pause(db, 2)
  107. self.assertIn("Cannot pause a cancelled task", str(ctx2.exception))
  108. async def test_pause_idempotent_on_paused_task(self):
  109. db = AsyncMock()
  110. task = VasTask(id=3, status="pause", order_id="ORD-03")
  111. mock_res = MagicMock()
  112. mock_res.scalar_one_or_none.return_value = task
  113. db.execute.return_value = mock_res
  114. res = await VasTaskService.pause(db, 3)
  115. self.assertEqual(res.status, "pause")
  116. db.commit.assert_not_called()
  117. async def test_pause_valid_task(self):
  118. db = AsyncMock()
  119. task = VasTask(id=4, status="pending", order_id="ORD-04")
  120. mock_res = MagicMock()
  121. mock_res.scalar_one_or_none.return_value = task
  122. db.execute.return_value = mock_res
  123. res = await VasTaskService.pause(db, 4)
  124. self.assertEqual(res.status, "pause")
  125. db.commit.assert_awaited_once()
  126. async def test_return_to_queue_rejects_completed_or_cancelled(self):
  127. db = AsyncMock()
  128. completed_task = VasTask(id=1, status="completed", order_id="ORD-01")
  129. mock_res1 = MagicMock()
  130. mock_res1.scalar_one_or_none.return_value = completed_task
  131. db.execute.return_value = mock_res1
  132. with self.assertRaises(BizLogicError) as ctx1:
  133. await VasTaskService.return_to_queue(db, 1)
  134. self.assertIn("Cannot return a completed task to queue", str(ctx1.exception))
  135. cancelled_task = VasTask(id=2, status="cancelled", order_id="ORD-02")
  136. mock_res2 = MagicMock()
  137. mock_res2.scalar_one_or_none.return_value = cancelled_task
  138. db.execute.return_value = mock_res2
  139. with self.assertRaises(BizLogicError) as ctx2:
  140. await VasTaskService.return_to_queue(db, 2)
  141. self.assertIn("Cannot return a cancelled task to queue", str(ctx2.exception))
  142. async def test_return_to_queue_rejects_closed_order(self):
  143. db = AsyncMock()
  144. task = VasTask(id=5, status="pause", order_id="ORD-CLOSED")
  145. closed_order = VasOrder(id="ORD-CLOSED", status="closed")
  146. task_mock = MagicMock()
  147. task_mock.scalar_one_or_none.return_value = task
  148. order_mock = MagicMock()
  149. order_mock.scalar_one_or_none.return_value = closed_order
  150. db.execute.side_effect = [task_mock, order_mock]
  151. with self.assertRaises(BizLogicError) as ctx:
  152. await VasTaskService.return_to_queue(db, 5)
  153. self.assertIn("associated order is closed", str(ctx.exception))
  154. async def test_return_to_queue_success(self):
  155. db = AsyncMock()
  156. task = VasTask(id=6, status="pause", order_id="ORD-PAID")
  157. order = VasOrder(id="ORD-PAID", status="paid")
  158. task_mock = MagicMock()
  159. task_mock.scalar_one_or_none.return_value = task
  160. order_mock = MagicMock()
  161. order_mock.scalar_one_or_none.return_value = order
  162. db.execute.side_effect = [task_mock, order_mock]
  163. res = await VasTaskService.return_to_queue(db, 6)
  164. self.assertEqual(res.status, "pending")
  165. db.commit.assert_awaited_once()
  166. if __name__ == "__main__":
  167. unittest.main()