| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211 |
- import unittest
- from unittest.mock import AsyncMock, MagicMock, patch
- from datetime import datetime
- from app.models.vas_task import VasTask
- from app.models.order import VasOrder
- from app.models.product_routing import VasProductRouting
- from app.schemas.order import VasOrderPatchUserInputs
- from app.core.biz_exception import BizLogicError
- from app.services.order_service import OrderService
- from app.services.webhook_service import WebhookService
- from app.services.vas_task_service import VasTaskService
- class TestVasTaskPauseGuards(unittest.IsolatedAsyncioTestCase):
- async def test_order_cancel_cancels_paused_task(self):
- db = AsyncMock()
- order = VasOrder(
- id="ORD-001",
- status="paid",
- product_id=1,
- user_inputs={}
- )
- paused_task = VasTask(
- id=10,
- order_id="ORD-001",
- routing_key="test.routing",
- status="pause"
- )
- order_mock = MagicMock()
- order_mock.scalar_one_or_none.return_value = order
- tasks_mock = MagicMock()
- tasks_mock.scalars.return_value.all.return_value = [paused_task]
- db.execute.side_effect = [order_mock, tasks_mock]
- cancelled_order = await OrderService.cancel(db, "ORD-001")
- self.assertEqual(cancelled_order.status, "closed")
- self.assertEqual(paused_task.status, "cancelled")
- db.commit.assert_awaited()
- async def test_order_patch_user_inputs_cancels_paused_task(self):
- db = AsyncMock()
- order = VasOrder(
- id="ORD-002",
- status="paid",
- product_id=1,
- user_inputs={"name": "Old"}
- )
- paused_task = VasTask(
- id=20,
- order_id="ORD-002",
- routing_key="test.routing",
- status="pause"
- )
- order_mock = MagicMock()
- order_mock.scalar_one_or_none.return_value = order
- tasks_mock = MagicMock()
- tasks_mock.scalars.return_value.all.return_value = [paused_task]
- db.execute.side_effect = [order_mock, tasks_mock]
- with patch.object(WebhookService, "_create_task_if_not_exists", new_callable=AsyncMock) as mock_create:
- payload = VasOrderPatchUserInputs(user_inputs={"name": "New"})
- patched_order = await OrderService.patch_user_inputs(db, "ORD-002", payload)
- self.assertEqual(paused_task.status, "cancelled")
- self.assertEqual(patched_order.user_inputs, {"name": "New"})
- mock_create.assert_awaited_once_with(db, order)
- async def test_webhook_create_task_skips_if_paused_task_exists(self):
- db = AsyncMock()
- order = VasOrder(
- id="ORD-003",
- product_id=1,
- status="paid",
- user_inputs={"email": "test@example.com"}
- )
- routing = VasProductRouting(
- id=1,
- product_id=1,
- routing_key="test.routing",
- is_active=1,
- priority=10,
- script_version="v1"
- )
- paused_task = VasTask(
- id=30,
- order_id="ORD-003",
- routing_key="test.routing",
- status="pause"
- )
- routings_mock = MagicMock()
- routings_mock.scalars.return_value.all.return_value = [routing]
- exists_mock = MagicMock()
- exists_mock.scalar_one_or_none.return_value = paused_task
- db.execute.side_effect = [routings_mock, exists_mock]
- created = await WebhookService._create_task_if_not_exists(db, order)
- # Should skip creation since paused task exists
- self.assertEqual(created, [])
- db.add.assert_not_called()
- async def test_pause_rejects_completed_or_cancelled_task(self):
- db = AsyncMock()
- completed_task = VasTask(id=1, status="completed", order_id="ORD-01")
- mock_res1 = MagicMock()
- mock_res1.scalar_one_or_none.return_value = completed_task
- db.execute.return_value = mock_res1
- with self.assertRaises(BizLogicError) as ctx1:
- await VasTaskService.pause(db, 1)
- self.assertIn("Cannot pause a completed task", str(ctx1.exception))
- cancelled_task = VasTask(id=2, status="cancelled", order_id="ORD-02")
- mock_res2 = MagicMock()
- mock_res2.scalar_one_or_none.return_value = cancelled_task
- db.execute.return_value = mock_res2
- with self.assertRaises(BizLogicError) as ctx2:
- await VasTaskService.pause(db, 2)
- self.assertIn("Cannot pause a cancelled task", str(ctx2.exception))
- async def test_pause_idempotent_on_paused_task(self):
- db = AsyncMock()
- task = VasTask(id=3, status="pause", order_id="ORD-03")
- mock_res = MagicMock()
- mock_res.scalar_one_or_none.return_value = task
- db.execute.return_value = mock_res
- res = await VasTaskService.pause(db, 3)
- self.assertEqual(res.status, "pause")
- db.commit.assert_not_called()
- async def test_pause_valid_task(self):
- db = AsyncMock()
- task = VasTask(id=4, status="pending", order_id="ORD-04")
- mock_res = MagicMock()
- mock_res.scalar_one_or_none.return_value = task
- db.execute.return_value = mock_res
- res = await VasTaskService.pause(db, 4)
- self.assertEqual(res.status, "pause")
- db.commit.assert_awaited_once()
- async def test_return_to_queue_rejects_completed_or_cancelled(self):
- db = AsyncMock()
- completed_task = VasTask(id=1, status="completed", order_id="ORD-01")
- mock_res1 = MagicMock()
- mock_res1.scalar_one_or_none.return_value = completed_task
- db.execute.return_value = mock_res1
- with self.assertRaises(BizLogicError) as ctx1:
- await VasTaskService.return_to_queue(db, 1)
- self.assertIn("Cannot return a completed task to queue", str(ctx1.exception))
- cancelled_task = VasTask(id=2, status="cancelled", order_id="ORD-02")
- mock_res2 = MagicMock()
- mock_res2.scalar_one_or_none.return_value = cancelled_task
- db.execute.return_value = mock_res2
- with self.assertRaises(BizLogicError) as ctx2:
- await VasTaskService.return_to_queue(db, 2)
- self.assertIn("Cannot return a cancelled task to queue", str(ctx2.exception))
- async def test_return_to_queue_rejects_closed_order(self):
- db = AsyncMock()
- task = VasTask(id=5, status="pause", order_id="ORD-CLOSED")
- closed_order = VasOrder(id="ORD-CLOSED", status="closed")
- task_mock = MagicMock()
- task_mock.scalar_one_or_none.return_value = task
- order_mock = MagicMock()
- order_mock.scalar_one_or_none.return_value = closed_order
- db.execute.side_effect = [task_mock, order_mock]
- with self.assertRaises(BizLogicError) as ctx:
- await VasTaskService.return_to_queue(db, 5)
- self.assertIn("associated order is closed", str(ctx.exception))
- async def test_return_to_queue_success(self):
- db = AsyncMock()
- task = VasTask(id=6, status="pause", order_id="ORD-PAID")
- order = VasOrder(id="ORD-PAID", status="paid")
- task_mock = MagicMock()
- task_mock.scalar_one_or_none.return_value = task
- order_mock = MagicMock()
- order_mock.scalar_one_or_none.return_value = order
- db.execute.side_effect = [task_mock, order_mock]
- res = await VasTaskService.return_to_queue(db, 6)
- self.assertEqual(res.status, "pending")
- db.commit.assert_awaited_once()
- if __name__ == "__main__":
- unittest.main()
|