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