niuniu/ShiErFeng
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

功能：隔离五类测试业务链路

Browse Source
This commit is contained in:
焦龙言
2026-09-23 08:27:14 +08:00
parent 43fe17cc70
commit f5df2150d8
18 changed files with 1206 additions and 831 deletions
Download Patch File Download Diff File Expand all files Collapse all files
shierfeng-fastapi-backend/tests/module_business/test_filling_service.py
+103 -44
View File
@@ -25,6 +25,7 @@ from module_business.dao.inventory_dao import InventoryDao
from module_business.dao.master_dao import MasterDao
from module_business.dao.operation_dao import OperationDao
from module_business.domain.enums import PalletEventType, PalletFlowState
from module_business.domain.test_batch_scope import TestBatchScope
from module_business.entity.do.master_do import BizPallet, BizStrain
from module_business.entity.do.operation_do import BizFillingRecord, BizPalletEvent, BizPalletInventory
from module_business.entity.vo.operation_vo import (
@@ -160,13 +161,24 @@ def make_filling(
class TestFillingPublicContract(unittest.TestCase):
def test_public_business_methods_require_explicit_test_scope(self) -> None:
for method_name in (
'get_filling_list_services',
'filling_detail_services',
'get_strain_options_services',
'scan_filling_pallet_services',
'fill_pallet_services',
):
with self.subTest(method=method_name):
self.assertIn('test_scope', inspect.signature(getattr(FillingService, method_name)).parameters)
def test_service_and_controller_are_available(self) -> None:
self.assertIsNotNone(FillingService)
self.assertIsNotNone(filling_controller_module.filling_controller)
def test_fill_signature_and_types_are_exact(self) -> None:
signature = inspect.signature(FillingService.fill_pallet_services)
self.assertEqual(('query_db', 'page_object', 'current_user'), tuple(signature.parameters))
self.assertEqual(('query_db', 'page_object', 'current_user', 'test_scope'), tuple(signature.parameters))
hints = get_type_hints(FillingService.fill_pallet_services)
self.assertIs(AsyncSession, hints['query_db'])
self.assertIs(FillingCreateModel, hints['page_object'])
@@ -217,9 +229,15 @@ class TestFillingReadServices(unittest.IsolatedAsyncioTestCase):
patch.object(AccessDao, 'list_user_warehouse_ids', new=AsyncMock(return_value=[9, 7, 7])),
patch.object(OperationDao, 'get_filling_list', new=get_list),
):
result = await FillingService.get_filling_list_services(self.db, query, self.user)
result = await FillingService.get_filling_list_services(self.db, query, self.user, TestBatchScope.formal())
get_list.assert_awaited_once_with(self.db, query, True, warehouse_ids=[7, 9])
get_list.assert_awaited_once_with(
self.db,
query,
warehouse_ids=[7, 9],
scope=TestBatchScope.formal(),
is_page=True,
)
self.assertIsInstance(result.rows[0], FillingModel)
self.assertEqual(1, result.total)
@@ -231,9 +249,15 @@ class TestFillingReadServices(unittest.IsolatedAsyncioTestCase):
patch.object(AccessDao, 'list_user_warehouse_ids', new=AsyncMock(return_value=[])),
patch.object(OperationDao, 'get_filling_list', new=get_list),
):
result = await FillingService.get_filling_list_services(self.db, query, self.user)
result = await FillingService.get_filling_list_services(self.db, query, self.user, TestBatchScope.formal())
get_list.assert_awaited_once_with(self.db, query, True, warehouse_ids=[])
get_list.assert_awaited_once_with(
self.db,
query,
warehouse_ids=[],
scope=TestBatchScope.formal(),
is_page=True,
)
self.assertEqual([], result.rows)
self.assertEqual(0, result.total)
@@ -245,7 +269,7 @@ class TestFillingReadServices(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'get_filling_list', new=get_list),
self.assertRaises(PermissionException),
):
await FillingService.get_filling_list_services(self.db, query, self.user)
await FillingService.get_filling_list_services(self.db, query, self.user, TestBatchScope.formal())
get_list.assert_not_awaited()
async def test_admin_list_is_unscoped(self) -> None:
@@ -256,9 +280,17 @@ class TestFillingReadServices(unittest.IsolatedAsyncioTestCase):
patch.object(AccessDao, 'list_user_warehouse_ids', new=scope),
patch.object(OperationDao, 'get_filling_list', new=get_list),
):
result = await FillingService.get_filling_list_services(self.db, query, make_user(1), is_page=False)
result = await FillingService.get_filling_list_services(
self.db, query, make_user(1), TestBatchScope.formal(), is_page=False
)
scope.assert_not_awaited()
get_list.assert_awaited_once_with(self.db, query, False, warehouse_ids=None)
get_list.assert_awaited_once_with(
self.db,
query,
warehouse_ids=None,
scope=TestBatchScope.formal(),
is_page=False,
)
self.assertEqual([], result)
async def test_detail_is_scoped_before_lookup_and_hides_missing_for_normal_user(self) -> None:
@@ -268,8 +300,8 @@ class TestFillingReadServices(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'get_filling_by_id', new=get_detail),
self.assertRaises(PermissionException) as raised,
):
await FillingService.filling_detail_services(self.db, 31, self.user)
get_detail.assert_awaited_once_with(self.db, 31, warehouse_ids=[7])
await FillingService.filling_detail_services(self.db, 31, self.user, TestBatchScope.formal())
get_detail.assert_awaited_once_with(self.db, 31, TestBatchScope.formal(), warehouse_ids=[7])
self.assertEqual('无权访问该装填记录', raised.exception.message)
async def test_admin_detail_keeps_precise_not_found_error(self) -> None:
@@ -278,8 +310,8 @@ class TestFillingReadServices(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'get_filling_by_id', new=get_detail),
self.assertRaises(ServiceException) as raised,
):
await FillingService.filling_detail_services(self.db, 31, make_user(1))
get_detail.assert_awaited_once_with(self.db, 31, warehouse_ids=None)
await FillingService.filling_detail_services(self.db, 31, make_user(1), TestBatchScope.formal())
get_detail.assert_awaited_once_with(self.db, 31, TestBatchScope.formal(), warehouse_ids=None)
self.assertEqual('装填记录不存在', raised.exception.message)
async def test_strain_options_return_only_enabled_business_options(self) -> None:
@@ -290,11 +322,12 @@ class TestFillingReadServices(unittest.IsolatedAsyncioTestCase):
]
list_strain = AsyncMock(return_value=strains)
with patch.object(MasterDao, 'list_strain', new=list_strain):
result = await FillingService.get_strain_options_services(self.db, self.user)
result = await FillingService.get_strain_options_services(self.db, self.user, TestBatchScope.formal())
query = list_strain.await_args.args[1]
self.assertEqual('0', query.status)
self.assertFalse(list_strain.await_args.args[2])
self.assertEqual(TestBatchScope.formal(), list_strain.await_args.args[2])
self.assertFalse(list_strain.await_args.args[3])
self.assertEqual([1, 3], [option.id for option in result])
self.assertTrue(all(isinstance(option, BusinessOptionModel) for option in result))
@@ -311,7 +344,9 @@ class TestFillingReadServices(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'get_inventory_for_update', new=inventory_lock),
patch.object(InventoryDao, 'get_pallets_by_ids', new=pallet_lock),
):
result = await FillingService.scan_filling_pallet_services(self.db, 'qr-2', self.user)
result = await FillingService.scan_filling_pallet_services(
self.db, 'qr-2', self.user, TestBatchScope.formal()
)
access.assert_awaited_once_with(self.db, self.user, 7)
inventory_lock.assert_not_awaited()
@@ -334,7 +369,7 @@ class TestFillingReadServices(unittest.IsolatedAsyncioTestCase):
patch.object(AccessService, 'assert_warehouse_access', new=access),
self.assertRaises(PermissionException) as raised,
):
await FillingService.scan_filling_pallet_services(self.db, 'qr-2', self.user)
await FillingService.scan_filling_pallet_services(self.db, 'qr-2', self.user, TestBatchScope.formal())
access.assert_awaited_once_with(self.db, self.user, 7)
self.assertEqual('', raised.exception.data)
self.assertEqual('无权访问该托盘', raised.exception.message)
@@ -346,7 +381,7 @@ class TestFillingReadServices(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'get_pallet_by_qr_token', new=AsyncMock(return_value=None)),
self.assertRaises(exception_type),
):
await FillingService.scan_filling_pallet_services(self.db, 'missing', user)
await FillingService.scan_filling_pallet_services(self.db, 'missing', user, TestBatchScope.formal())
async def test_scan_admin_distinguishes_missing_inventory(self) -> None:
with (
@@ -354,7 +389,7 @@ class TestFillingReadServices(unittest.IsolatedAsyncioTestCase):
patch.object(MasterDao, 'get_pallet_inventory', new=AsyncMock(return_value=None)),
self.assertRaises(ServiceException) as raised,
):
await FillingService.scan_filling_pallet_services(self.db, 'qr-2', make_user(1))
await FillingService.scan_filling_pallet_services(self.db, 'qr-2', make_user(1), TestBatchScope.formal())
self.assertEqual('托盘库存不存在', raised.exception.message)
@@ -441,7 +476,7 @@ class TestFillPalletService(unittest.IsolatedAsyncioTestCase):
patch('module_business.service.filling_service.datetime') as mocked_datetime,
):
mocked_datetime.now.return_value = self.fixed_time
result = await FillingService.fill_pallet_services(self.db, self.page, self.user)
result = await FillingService.fill_pallet_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertEqual(
[
@@ -460,8 +495,8 @@ class TestFillPalletService(unittest.IsolatedAsyncioTestCase):
[False, False, True], [call.kwargs.get('for_update', False) for call in access.await_args_list]
)
self.assertEqual([7, 7, 7], [call.args[2] for call in access.await_args_list])
warehouse_read.assert_awaited_once_with(self.db, 7, for_update=True)
strain_read.assert_awaited_once_with(self.db, 11, for_update=True)
warehouse_read.assert_awaited_once_with(self.db, 7, TestBatchScope.formal(), for_update=True)
strain_read.assert_awaited_once_with(self.db, 11, TestBatchScope.formal(), for_update=True)
filling = captured['filling']
self.assertTrue(filling.filling_no.startswith('FL-'))
self.assertEqual(2, filling.pallet_id)
@@ -539,7 +574,7 @@ class TestFillPalletService(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'add_event', new=add_event),
self.assertRaises(ServiceException),
):
await FillingService.fill_pallet_services(self.db, page or self.page, self.user)
await FillingService.fill_pallet_services(self.db, page or self.page, self.user, TestBatchScope.formal())
add_filling.assert_not_awaited()
add_event.assert_not_awaited()
self.db.commit.assert_not_awaited()
@@ -580,11 +615,11 @@ class TestFillPalletService(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'add_event', new=add_event),
self.assertRaises(ServiceException) as raised,
):
await FillingService.fill_pallet_services(self.db, self.page, self.user)
await FillingService.fill_pallet_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertEqual('仓库已停用', raised.exception.message)
self.assertEqual(['inventory-lock', 'pallet-lock', 'warehouse-read'], actions)
warehouse_read.assert_awaited_once_with(self.db, 7, for_update=True)
warehouse_read.assert_awaited_once_with(self.db, 7, TestBatchScope.formal(), for_update=True)
strain_read.assert_not_awaited()
add_filling.assert_not_awaited()
add_event.assert_not_awaited()
@@ -639,7 +674,7 @@ class TestFillPalletService(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'add_event', new=add_event),
self.assertRaises(PermissionException) as raised,
):
await FillingService.fill_pallet_services(self.db, self.page, self.user)
await FillingService.fill_pallet_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertEqual('', raised.exception.data)
self.assertEqual('无权访问该托盘', raised.exception.message)
@@ -651,7 +686,7 @@ class TestFillPalletService(unittest.IsolatedAsyncioTestCase):
[False, False, True], [call.kwargs.get('for_update', False) for call in access.await_args_list]
)
self.assertEqual([7, 7, 7], [call.args[2] for call in access.await_args_list])
warehouse_read.assert_awaited_once_with(self.db, 7, for_update=True)
warehouse_read.assert_awaited_once_with(self.db, 7, TestBatchScope.formal(), for_update=True)
strain_read.assert_not_awaited()
add_filling.assert_not_awaited()
add_event.assert_not_awaited()
@@ -676,7 +711,7 @@ class TestFillPalletService(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'add_filling_record', new=add_filling),
self.assertRaises(ServiceException),
):
await FillingService.fill_pallet_services(self.db, self.page, self.user)
await FillingService.fill_pallet_services(self.db, self.page, self.user, TestBatchScope.formal())
add_filling.assert_not_awaited()
self.db.rollback.assert_awaited_once()
@@ -717,9 +752,14 @@ class TestFillPalletService(unittest.IsolatedAsyncioTestCase):
patch.object(MasterDao, 'get_warehouse', new=warehouse_read),
patch.object(MasterDao, 'get_strain', new=strain_read),
):
result = await FillingService.fill_pallet_services(self.db, self.page, self.user)
result = await FillingService.fill_pallet_services(self.db, self.page, self.user, TestBatchScope.formal())
get_key.assert_awaited_once_with(self.db, 'fill-key', warehouse_ids=[7])
get_key.assert_awaited_once_with(
self.db,
'fill-key',
TestBatchScope.formal(),
warehouse_ids=[7],
)
access.assert_awaited_once_with(self.db, self.user, 7)
inventory_lock.assert_not_awaited()
warehouse_read.assert_not_awaited()
@@ -741,9 +781,16 @@ class TestFillPalletService(unittest.IsolatedAsyncioTestCase):
patch.object(AccessService, 'assert_warehouse_access', new=AsyncMock()),
patch.object(OperationDao, 'get_filling_by_idempotency_key', new=get_key),
):
result = await FillingService.fill_pallet_services(self.db, self.page, user)
result = await FillingService.fill_pallet_services(
self.db, self.page, user, TestBatchScope.formal()
)
get_key.assert_awaited_once_with(self.db, 'fill-key', warehouse_ids=[7])
get_key.assert_awaited_once_with(
self.db,
'fill-key',
TestBatchScope.formal(),
warehouse_ids=[7],
)
self.assertEqual(31, result.result)
if user.user and user.user.admin:
scope_read.assert_not_awaited()
@@ -756,7 +803,7 @@ class TestFillPalletService(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'get_filling_by_idempotency_key', new=AsyncMock(return_value=existing)),
self.assertRaises(ServiceException) as raised,
):
await FillingService.fill_pallet_services(self.db, self.page, self.user)
await FillingService.fill_pallet_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertIn('幂等键', raised.exception.message)
self.db.rollback.assert_awaited_once()
@@ -767,7 +814,7 @@ class TestFillPalletService(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'get_filling_by_idempotency_key', new=get_key),
self.assertRaises(PermissionException) as raised,
):
await FillingService.fill_pallet_services(self.db, self.page, self.user)
await FillingService.fill_pallet_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertEqual('', raised.exception.data)
self.assertEqual('无权访问该仓库', raised.exception.message)
get_key.assert_not_awaited()
@@ -802,7 +849,7 @@ class TestFillPalletService(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'add_event', new=add_event),
self.assertRaises(PermissionException) as raised,
):
await FillingService.fill_pallet_services(self.db, self.page, self.user)
await FillingService.fill_pallet_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertEqual([7, foreign_warehouse_id], [call.args[2] for call in access.await_args_list])
self.assertEqual('', raised.exception.data)
@@ -856,7 +903,7 @@ class TestFillPalletService(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'add_filling_record', new=add_filling),
patch.object(InventoryDao, 'add_event', new=add_event),
):
result = await FillingService.fill_pallet_services(self.db, self.page, self.user)
result = await FillingService.fill_pallet_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertEqual(['inventory-lock', 'pallet-lock', 'filling-lock'], actions)
self.assertEqual(2, get_key.await_count)
@@ -893,7 +940,7 @@ class TestFillPalletService(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'add_filling_record', new=add_filling),
self.assertRaises(ServiceException) as raised,
):
await FillingService.fill_pallet_services(self.db, self.page, self.user)
await FillingService.fill_pallet_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertEqual('装填失败，幂等键已被其他请求使用', raised.exception.message)
self.assertEqual(2, get_key.await_count)
@@ -914,7 +961,7 @@ class TestFillPalletService(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'add_filling_record', new=AsyncMock(side_effect=RuntimeError('flush failed'))),
self.assertRaises(RuntimeError),
):
await FillingService.fill_pallet_services(self.db, self.page, self.user)
await FillingService.fill_pallet_services(self.db, self.page, self.user, TestBatchScope.formal())
self.db.rollback.assert_awaited_once()
self.db.commit.assert_not_awaited()
@@ -923,7 +970,7 @@ class TestFillPalletService(unittest.IsolatedAsyncioTestCase):
patch.object(FillingService, '_build_request_hash', side_effect=RuntimeError('hash failed')),
self.assertRaises(RuntimeError),
):
await FillingService.fill_pallet_services(self.db, self.page, self.user)
await FillingService.fill_pallet_services(self.db, self.page, self.user, TestBatchScope.formal())
self.db.rollback.assert_awaited_once()
self.db.commit.assert_not_awaited()
@@ -942,7 +989,7 @@ class TestFillPalletService(unittest.IsolatedAsyncioTestCase):
patch.object(MasterDao, 'get_strain', new=AsyncMock(return_value=self.strain)),
patch.object(OperationDao, 'add_filling_record', new=AsyncMock(side_effect=integrity_error())),
):
result = await FillingService.fill_pallet_services(self.db, self.page, self.user)
result = await FillingService.fill_pallet_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertEqual(2, key_reads.await_count)
self.assertEqual(
@@ -968,7 +1015,7 @@ class TestFillPalletService(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'add_filling_record', new=AsyncMock(side_effect=integrity_error())),
self.assertRaises(PermissionException) as raised,
):
await FillingService.fill_pallet_services(self.db, self.page, self.user)
await FillingService.fill_pallet_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertEqual('无权访问该仓库', raised.exception.message)
self.assertEqual(2, warehouse_scope.await_count)
@@ -993,7 +1040,7 @@ class TestFillPalletService(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'add_filling_record', new=AsyncMock(side_effect=integrity_error())),
self.assertRaises(ServiceException) as raised,
):
await FillingService.fill_pallet_services(self.db, self.page, self.user)
await FillingService.fill_pallet_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertEqual('装填失败，数据冲突', raised.exception.message)
self.assertEqual(2, self.db.rollback.await_count)
self.db.commit.assert_not_awaited()
@@ -1009,7 +1056,13 @@ class TestFillingOperationDaoScope(unittest.IsolatedAsyncioTestCase):
paginate = AsyncMock(return_value=[])
db = MagicMock(spec=AsyncSession)
with patch.object(OperationDao, '_paginate', new=paginate):
await OperationDao.get_filling_list(db, query, False, warehouse_ids=[9, 7, 7])
await OperationDao.get_filling_list(
db,
query,
warehouse_ids=[9, 7, 7],
scope=TestBatchScope.formal(),
is_page=False,
)
sql = self._compiled(paginate.await_args.args[1])
self.assertIn('biz_filling_record.warehouse_id in (7, 9)', sql)
@@ -1018,7 +1071,13 @@ class TestFillingOperationDaoScope(unittest.IsolatedAsyncioTestCase):
paginate = AsyncMock(return_value=[])
db = MagicMock(spec=AsyncSession)
with patch.object(OperationDao, '_paginate', new=paginate):
await OperationDao.get_filling_list(db, query, False, warehouse_ids=[])
await OperationDao.get_filling_list(
db,
query,
warehouse_ids=[],
scope=TestBatchScope.formal(),
is_page=False,
)
sql = self._compiled(paginate.await_args.args[1])
self.assertTrue('false' in sql or '0 = 1' in sql, sql)
@@ -1032,7 +1091,7 @@ class TestFillingOperationDaoScope(unittest.IsolatedAsyncioTestCase):
result.scalar_one_or_none.return_value = None
db = MagicMock(spec=AsyncSession)
db.execute.return_value = result
await method(db, key, warehouse_ids=[7])
await method(db, key, TestBatchScope.formal(), warehouse_ids=[7])
sql = self._compiled(db.execute.await_args.args[0])
self.assertIn('biz_filling_record.warehouse_id in (7)', sql)
shierfeng-fastapi-backend/tests/module_business/test_inbound_service.py
+188 -187
View File
@@ -22,7 +22,7 @@ from common.vo import (
PageResponseModel,
ResponseBaseModel,
)
from exceptions.exception import PermissionException, ServiceException
from exceptions.exception import PermissionException, ServiceException, ServiceWarning
from module_admin.entity.vo.user_vo import CurrentUserModel, UserInfoModel
from module_admin.service.log_service import LogQueueService
from module_admin.service.login_service import LoginService
@@ -33,6 +33,7 @@ from module_business.dao.master_dao import MasterDao
from module_business.dao.operation_dao import OperationDao
from module_business.domain.enums import PalletEventType, PalletFlowState
from module_business.domain.pallet_state_machine import PalletStateMachine
from module_business.domain.test_batch_scope import TestBatchScope
from module_business.entity.do.master_do import BizPallet
from module_business.entity.do.operation_do import (
BizInboundItem,
@@ -129,6 +130,20 @@ def make_inbound(
class TestInboundPublicContract(unittest.TestCase):
def test_public_business_methods_require_explicit_test_scope(self) -> None:
for method_name in (
'get_inbound_list_services',
'inbound_detail_services',
'get_warehouse_options_services',
'scan_inbound_pallet_services',
'add_inbound_services',
'edit_inbound_services',
'delete_inbound_services',
'confirm_inbound_services',
):
with self.subTest(method=method_name):
self.assertIn('test_scope', inspect.signature(getattr(InboundService, method_name)).parameters)
def test_service_and_controller_are_available(self) -> None:
self.assertIsNotNone(InboundService)
self.assertIsNotNone(inbound_controller_module.inbound_controller)
@@ -136,7 +151,7 @@ class TestInboundPublicContract(unittest.TestCase):
def test_confirm_signature_and_types_are_exact(self) -> None:
signature = inspect.signature(InboundService.confirm_inbound_services)
self.assertEqual(
('query_db', 'inbound_id', 'page_object', 'current_user'),
('query_db', 'inbound_id', 'page_object', 'current_user', 'test_scope'),
tuple(signature.parameters),
)
hints = get_type_hints(InboundService.confirm_inbound_services)
@@ -228,7 +243,7 @@ class TestInboundDraftService(unittest.IsolatedAsyncioTestCase):
patch.object(inbound_service_module, 'datetime') as service_datetime,
):
service_datetime.now.return_value = self.fixed_time
result = await InboundService.add_inbound_services(self.db, page, self.user)
result = await InboundService.add_inbound_services(self.db, page, self.user, TestBatchScope.formal())
self.assertEqual(
[
@@ -242,8 +257,8 @@ class TestInboundDraftService(unittest.IsolatedAsyncioTestCase):
],
actions,
)
inventory_lock.assert_awaited_once_with(self.db, [2, 5])
pallet_lock.assert_awaited_once_with(self.db, [2, 5])
inventory_lock.assert_awaited_once_with(self.db, [2, 5], TestBatchScope.formal())
pallet_lock.assert_awaited_once_with(self.db, [2, 5], TestBatchScope.formal())
token_hex.assert_called_once_with(16)
order = captured['order']
self.assertEqual('IN-fixed-random', order.inbound_no)
@@ -288,7 +303,7 @@ class TestInboundDraftService(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'add_event', new=add_event),
self.assertRaises(ServiceException),
):
await InboundService.add_inbound_services(self.db, page, self.user)
await InboundService.add_inbound_services(self.db, page, self.user, TestBatchScope.formal())
add_order.assert_not_awaited()
replace_items.assert_not_awaited()
@@ -313,7 +328,7 @@ class TestInboundDraftService(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'get_inventories_for_update', new=lock),
self.assertRaises(exception_type),
):
await InboundService.add_inbound_services(self.db, page, self.user)
await InboundService.add_inbound_services(self.db, page, self.user, TestBatchScope.formal())
lock.assert_not_awaited()
self.db.rollback.assert_awaited_once()
@@ -333,7 +348,7 @@ class TestInboundDraftService(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'get_inventories_for_update', new=lock),
self.assertRaises(PermissionException),
):
await InboundService.add_inbound_services(self.db, page, self.user)
await InboundService.add_inbound_services(self.db, page, self.user, TestBatchScope.formal())
lock.assert_not_awaited()
self.db.rollback.assert_awaited_once()
@@ -351,7 +366,7 @@ class TestInboundDraftService(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'get_inventories_for_update', new=pallet_lock),
self.assertRaises(Exception) as raised,
):
await InboundService.add_inbound_services(self.db, page, self.user)
await InboundService.add_inbound_services(self.db, page, self.user, TestBatchScope.formal())
self.assertIsInstance(raised.exception, PermissionException)
self.assertEqual('无权访问该仓库', raised.exception.message)
@@ -385,11 +400,11 @@ class TestInboundDraftService(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'replace_inbound_items', new=replace_items),
self.assertRaises(PermissionException) as raised,
):
await InboundService.add_inbound_services(self.db, page, self.user)
await InboundService.add_inbound_services(self.db, page, self.user, TestBatchScope.formal())
self.assertEqual('无权访问该仓库', raised.exception.message)
self.assertEqual(2, warehouse_read.await_count)
warehouse_read.assert_awaited_with(self.db, 7, for_update=True)
warehouse_read.assert_awaited_with(self.db, 7, TestBatchScope.formal(), for_update=True)
self.assertEqual(2, warehouse_mapping.await_count)
warehouse_mapping.assert_awaited_with(self.db, self.user, 7, for_update=True)
add_order.assert_not_awaited()
@@ -427,12 +442,13 @@ class TestInboundDraftService(unittest.IsolatedAsyncioTestCase):
patch.object(inbound_service_module, 'datetime') as service_datetime,
):
service_datetime.now.return_value = self.fixed_time
result = await InboundService.edit_inbound_services(self.db, page, self.user)
result = await InboundService.edit_inbound_services(self.db, page, self.user, TestBatchScope.formal())
self.default_scope.assert_awaited_once_with(self.db, 7)
lock_order.assert_awaited_once_with(
self.db,
11,
TestBatchScope.formal(),
warehouse_ids=[2, 5, 7, 8, 11],
)
self.assertEqual(
@@ -443,8 +459,8 @@ class TestInboundDraftService(unittest.IsolatedAsyncioTestCase):
],
access.await_args_list,
)
inventory_lock.assert_awaited_once_with(self.db, [2, 5])
pallet_lock.assert_awaited_once_with(self.db, [2, 5])
inventory_lock.assert_awaited_once_with(self.db, [2, 5], TestBatchScope.formal())
pallet_lock.assert_awaited_once_with(self.db, [2, 5], TestBatchScope.formal())
self.assertEqual(8, inbound.warehouse_id)
self.assertEqual('user-7', inbound.update_by)
self.assertEqual(self.fixed_time, inbound.update_time)
@@ -478,7 +494,7 @@ class TestInboundDraftService(unittest.IsolatedAsyncioTestCase):
MasterDao,
'get_warehouse',
new=AsyncMock(
side_effect=lambda _db, warehouse_id, **_kwargs: SimpleNamespace(
side_effect=lambda _db, warehouse_id, _scope, **_kwargs: SimpleNamespace(
warehouse_id=warehouse_id,
status='0',
)
@@ -493,7 +509,7 @@ class TestInboundDraftService(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'replace_inbound_items', new=replace),
self.assertRaises(PermissionException) as raised,
):
await InboundService.edit_inbound_services(self.db, page, self.user)
await InboundService.edit_inbound_services(self.db, page, self.user, TestBatchScope.formal())
self.assertEqual('无权访问该入库单', raised.exception.message)
warehouse_mapping.assert_any_await(self.db, self.user, 7, for_update=True)
@@ -519,7 +535,7 @@ class TestInboundDraftService(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'update_inbound', new=update),
self.assertRaises(ServiceException),
):
await InboundService.edit_inbound_services(self.db, page, self.user)
await InboundService.edit_inbound_services(self.db, page, self.user, TestBatchScope.formal())
lock_pallets.assert_not_awaited()
update.assert_not_awaited()
@@ -537,12 +553,12 @@ class TestInboundDraftService(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'get_inventories_for_update', new=inventory_lock),
self.assertRaises(Exception) as raised,
):
await InboundService.edit_inbound_services(self.db, page, self.user)
await InboundService.edit_inbound_services(self.db, page, self.user, TestBatchScope.formal())
self.assertIsInstance(raised.exception, PermissionException)
self.assertEqual('无权访问该入库单', raised.exception.message)
scope.assert_awaited_once_with(self.db, 7)
lock_order.assert_awaited_once_with(self.db, 404, warehouse_ids=[7])
lock_order.assert_awaited_once_with(self.db, 404, TestBatchScope.formal(), warehouse_ids=[7])
get_warehouse.assert_not_awaited()
inventory_lock.assert_not_awaited()
self.db.rollback.assert_awaited_once()
@@ -556,130 +572,54 @@ class TestInboundDraftService(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'get_inbound_for_update', new=lock_order),
self.assertRaises(ServiceException) as raised,
):
await InboundService.edit_inbound_services(self.db, page, make_user(1))
await InboundService.edit_inbound_services(self.db, page, make_user(1), TestBatchScope.formal())
self.assertEqual('入库单不存在', raised.exception.message)
scope.assert_not_awaited()
lock_order.assert_awaited_once_with(self.db, 404, warehouse_ids=None)
lock_order.assert_awaited_once_with(self.db, 404, TestBatchScope.formal(), warehouse_ids=None)
self.db.rollback.assert_awaited_once()
async def test_batch_delete_locks_and_preflights_all_before_ordered_delete(self) -> None:
actions: list[str] = []
async def lock(
_db: AsyncSession,
inbound_id: int,
warehouse_ids: list[int] | None = None,
) -> BizInboundOrder:
self.assertEqual([2, 5, 7, 8, 11], warehouse_ids)
actions.append(f'lock-{inbound_id}')
return make_inbound(inbound_id=inbound_id, warehouse_id=inbound_id)
async def delete(_db: AsyncSession, inbound_id: int) -> None:
actions.append(f'delete-{inbound_id}')
async def commit() -> None:
actions.append('commit')
self.db.commit.side_effect = commit
access = AsyncMock()
lock = AsyncMock()
delete = AsyncMock()
with (
patch.object(OperationDao, 'get_inbound_for_update', new=AsyncMock(side_effect=lock)),
patch.object(
MasterDao,
'get_warehouse',
new=AsyncMock(
side_effect=lambda _db, warehouse_id, **_kwargs: SimpleNamespace(
warehouse_id=warehouse_id,
status='0',
)
),
),
patch.object(AccessService, 'assert_warehouse_access', new=access),
patch.object(OperationDao, 'delete_inbound', new=AsyncMock(side_effect=delete)),
patch.object(OperationDao, 'get_inbound_for_update', new=lock),
patch.object(OperationDao, 'delete_inbound', new=delete),
self.assertRaises(ServiceWarning),
):
result = await InboundService.delete_inbound_services(self.db, [5, 2], self.user)
await InboundService.delete_inbound_services(self.db, [5, 2], self.user, TestBatchScope.formal())
self.assertEqual(
['lock-2', 'lock-5', 'delete-2', 'delete-5', 'commit'],
actions,
)
self.default_scope.assert_awaited_once_with(self.db, 7)
self.assertEqual([2, 5], [call.args[2] for call in access.await_args_list])
self.assertTrue(all(call.kwargs.get('for_update') for call in access.await_args_list))
self.assertTrue(result.is_success)
self.db.rollback.assert_not_awaited()
lock.assert_not_awaited()
delete.assert_not_awaited()
self.db.commit.assert_not_awaited()
async def test_batch_delete_rechecks_all_current_warehouses_before_first_delete(self) -> None:
revoked_warehouse_id = 8
documents = {
11: make_inbound(inbound_id=11, warehouse_id=revoked_warehouse_id),
12: make_inbound(inbound_id=12, warehouse_id=7),
}
async def warehouse_access(
_db: AsyncSession,
_user: CurrentUserModel,
warehouse_id: int,
**kwargs: Any,
) -> None:
if warehouse_id == revoked_warehouse_id and kwargs.get('for_update'):
raise PermissionException(data='', message='无权访问该仓库')
lock = AsyncMock()
delete = AsyncMock()
warehouse_mapping = AsyncMock(side_effect=warehouse_access)
with (
patch.object(
OperationDao,
'get_inbound_for_update',
new=AsyncMock(side_effect=lambda _db, inbound_id, **_kwargs: documents[inbound_id]),
),
patch.object(
MasterDao,
'get_warehouse',
new=AsyncMock(
side_effect=lambda _db, warehouse_id, **_kwargs: SimpleNamespace(
warehouse_id=warehouse_id,
status='0',
)
),
),
patch.object(AccessService, 'assert_warehouse_access', new=warehouse_mapping),
patch.object(OperationDao, 'get_inbound_for_update', new=lock),
patch.object(OperationDao, 'delete_inbound', new=delete),
self.assertRaises(PermissionException) as raised,
self.assertRaises(ServiceWarning),
):
await InboundService.delete_inbound_services(self.db, [12, 11], self.user)
await InboundService.delete_inbound_services(self.db, [12, 11], self.user, TestBatchScope.formal())
self.assertEqual('无权访问该入库单', raised.exception.message)
self.assertEqual([7, 8], [call.args[2] for call in warehouse_mapping.await_args_list])
self.assertTrue(all(call.kwargs.get('for_update') for call in warehouse_mapping.await_args_list))
lock.assert_not_awaited()
delete.assert_not_awaited()
self.db.commit.assert_not_awaited()
self.db.rollback.assert_awaited_once()
async def test_batch_delete_is_atomic_when_later_document_is_confirmed(self) -> None:
lock = AsyncMock()
delete = AsyncMock()
records = {
2: make_inbound(inbound_id=2, warehouse_id=2),
5: make_inbound(inbound_id=5, warehouse_id=5, status='CONFIRMED'),
}
with (
patch.object(
OperationDao,
'get_inbound_for_update',
new=AsyncMock(
side_effect=lambda _db, inbound_id, warehouse_ids=None: records[inbound_id],
),
),
patch.object(AccessService, 'assert_warehouse_access', new=AsyncMock()),
patch.object(OperationDao, 'get_inbound_for_update', new=lock),
patch.object(OperationDao, 'delete_inbound', new=delete),
self.assertRaises(ServiceException),
self.assertRaises(ServiceWarning),
):
await InboundService.delete_inbound_services(self.db, [5, 2], self.user)
await InboundService.delete_inbound_services(self.db, [5, 2], self.user, TestBatchScope.formal())
lock.assert_not_awaited()
delete.assert_not_awaited()
self.db.commit.assert_not_awaited()
self.db.rollback.assert_awaited_once()
async def test_delete_scopes_parent_lock_and_hides_unmatched_document(self) -> None:
lock_order = AsyncMock(return_value=None)
@@ -688,16 +628,13 @@ class TestInboundDraftService(unittest.IsolatedAsyncioTestCase):
patch.object(AccessDao, 'list_user_warehouse_ids', new=AsyncMock(return_value=[7])) as scope,
patch.object(OperationDao, 'get_inbound_for_update', new=lock_order),
patch.object(OperationDao, 'delete_inbound', new=delete),
self.assertRaises(Exception) as raised,
self.assertRaises(ServiceWarning),
):
await InboundService.delete_inbound_services(self.db, [404], self.user)
await InboundService.delete_inbound_services(self.db, [404], self.user, TestBatchScope.formal())
self.assertIsInstance(raised.exception, PermissionException)
self.assertEqual('无权访问该入库单', raised.exception.message)
scope.assert_awaited_once_with(self.db, 7)
lock_order.assert_awaited_once_with(self.db, 404, warehouse_ids=[7])
scope.assert_not_awaited()
lock_order.assert_not_awaited()
delete.assert_not_awaited()
self.db.rollback.assert_awaited_once()
async def test_admin_missing_delete_keeps_precise_not_found(self) -> None:
scope = AsyncMock()
@@ -705,14 +642,12 @@ class TestInboundDraftService(unittest.IsolatedAsyncioTestCase):
with (
patch.object(AccessDao, 'list_user_warehouse_ids', new=scope),
patch.object(OperationDao, 'get_inbound_for_update', new=lock_order),
self.assertRaises(ServiceException) as raised,
self.assertRaises(ServiceWarning),
):
await InboundService.delete_inbound_services(self.db, [404], make_user(1))
await InboundService.delete_inbound_services(self.db, [404], make_user(1), TestBatchScope.formal())
self.assertEqual('入库单不存在', raised.exception.message)
scope.assert_not_awaited()
lock_order.assert_awaited_once_with(self.db, 404, warehouse_ids=None)
self.db.rollback.assert_awaited_once()
lock_order.assert_not_awaited()
async def test_all_draft_mutations_convert_integrity_errors(self) -> None:
add_page = InboundCreateModel(warehouseId=7, palletIds=[2])
@@ -732,7 +667,7 @@ class TestInboundDraftService(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'add_inbound', new=AsyncMock(side_effect=integrity_error())),
self.assertRaises(ServiceException),
):
await InboundService.add_inbound_services(self.db, add_page, self.user)
await InboundService.add_inbound_services(self.db, add_page, self.user, TestBatchScope.formal())
self.db.rollback.assert_awaited_once()
self.db.reset_mock()
@@ -749,10 +684,9 @@ class TestInboundDraftService(unittest.IsolatedAsyncioTestCase):
),
patch.object(AccessService, 'assert_warehouse_access', new=AsyncMock()),
patch.object(OperationDao, 'delete_inbound', new=AsyncMock(side_effect=integrity_error())),
self.assertRaises(ServiceException),
self.assertRaises(ServiceWarning),
):
await InboundService.delete_inbound_services(self.db, [11], self.user)
self.db.rollback.assert_awaited_once()
await InboundService.delete_inbound_services(self.db, [11], self.user, TestBatchScope.formal())
class TestInboundReadService(unittest.IsolatedAsyncioTestCase):
@@ -774,10 +708,18 @@ class TestInboundReadService(unittest.IsolatedAsyncioTestCase):
patch.object(AccessDao, 'list_user_warehouse_ids', new=AsyncMock(return_value=[7, 3, 7])) as scope,
patch.object(OperationDao, 'get_inbound_list', new=get_list),
):
actual = await InboundService.get_inbound_list_services(self.db, query, self.user, is_page=True)
actual = await InboundService.get_inbound_list_services(
self.db, query, self.user, TestBatchScope.formal(), is_page=True
)
scope.assert_awaited_once_with(self.db, 7)
get_list.assert_awaited_once_with(self.db, query, True, warehouse_ids=[3, 7])
get_list.assert_awaited_once_with(
self.db,
query,
warehouse_ids=[3, 7],
scope=TestBatchScope.formal(),
is_page=True,
)
self.assertIsInstance(actual, PageModel)
self.assertIsInstance(actual.rows[0], InboundModel)
@@ -790,10 +732,18 @@ class TestInboundReadService(unittest.IsolatedAsyncioTestCase):
patch.object(AccessDao, 'list_user_warehouse_ids', new=scope),
patch.object(OperationDao, 'get_inbound_list', new=get_list),
):
await InboundService.get_inbound_list_services(self.db, query, make_user(1), is_page=True)
await InboundService.get_inbound_list_services(
self.db, query, make_user(1), TestBatchScope.formal(), is_page=True
)
scope.assert_not_awaited()
get_list.assert_awaited_once_with(self.db, query, True, warehouse_ids=None)
get_list.assert_awaited_once_with(
self.db,
query,
warehouse_ids=None,
scope=TestBatchScope.formal(),
is_page=True,
)
async def test_explicit_unauthorized_warehouse_is_403_before_query(self) -> None:
query = InboundPageQueryModel(warehouseId=9)
@@ -803,7 +753,9 @@ class TestInboundReadService(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'get_inbound_list', new=get_list),
self.assertRaises(PermissionException),
):
await InboundService.get_inbound_list_services(self.db, query, self.user, is_page=True)
await InboundService.get_inbound_list_services(
self.db, query, self.user, TestBatchScope.formal(), is_page=True
)
get_list.assert_not_awaited()
async def test_user_without_scope_gets_empty_paginated_result_without_total_leak(self) -> None:
@@ -814,9 +766,17 @@ class TestInboundReadService(unittest.IsolatedAsyncioTestCase):
patch.object(AccessDao, 'list_user_warehouse_ids', new=AsyncMock(return_value=[])),
patch.object(OperationDao, 'get_inbound_list', new=get_list),
):
actual = await InboundService.get_inbound_list_services(self.db, query, self.user, is_page=True)
actual = await InboundService.get_inbound_list_services(
self.db, query, self.user, TestBatchScope.formal(), is_page=True
)
get_list.assert_awaited_once_with(self.db, query, True, warehouse_ids=[])
get_list.assert_awaited_once_with(
self.db,
query,
warehouse_ids=[],
scope=TestBatchScope.formal(),
is_page=True,
)
self.assertEqual([], actual.rows)
self.assertEqual(0, actual.total)
self.assertFalse(actual.has_next)
@@ -834,10 +794,10 @@ class TestInboundReadService(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'get_inbound_by_id', new=get_detail),
patch.object(AccessService, 'assert_warehouse_access', new=access),
):
actual = await InboundService.inbound_detail_services(self.db, 11, self.user)
actual = await InboundService.inbound_detail_services(self.db, 11, self.user, TestBatchScope.formal())
scope.assert_awaited_once_with(self.db, 7)
get_detail.assert_awaited_once_with(self.db, 11, warehouse_ids=[3, 7])
get_detail.assert_awaited_once_with(self.db, 11, TestBatchScope.formal(), warehouse_ids=[3, 7])
access.assert_not_awaited()
self.assertIsInstance(actual, InboundModel)
@@ -848,11 +808,11 @@ class TestInboundReadService(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'get_inbound_by_id', new=get_detail),
self.assertRaises(Exception) as raised,
):
await InboundService.inbound_detail_services(self.db, 404, self.user)
await InboundService.inbound_detail_services(self.db, 404, self.user, TestBatchScope.formal())
self.assertIsInstance(raised.exception, PermissionException)
self.assertEqual('无权访问该入库单', raised.exception.message)
get_detail.assert_awaited_once_with(self.db, 404, warehouse_ids=[7])
get_detail.assert_awaited_once_with(self.db, 404, TestBatchScope.formal(), warehouse_ids=[7])
async def test_admin_missing_detail_keeps_precise_not_found(self) -> None:
scope = AsyncMock()
@@ -862,11 +822,11 @@ class TestInboundReadService(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'get_inbound_by_id', new=get_detail),
self.assertRaises(ServiceException) as raised,
):
await InboundService.inbound_detail_services(self.db, 404, make_user(1))
await InboundService.inbound_detail_services(self.db, 404, make_user(1), TestBatchScope.formal())
self.assertEqual('入库单不存在', raised.exception.message)
scope.assert_not_awaited()
get_detail.assert_awaited_once_with(self.db, 404, warehouse_ids=None)
get_detail.assert_awaited_once_with(self.db, 404, TestBatchScope.formal(), warehouse_ids=None)
async def test_warehouse_options_filter_disabled_and_unauthorized_records(self) -> None:
warehouses = [
@@ -878,11 +838,12 @@ class TestInboundReadService(unittest.IsolatedAsyncioTestCase):
patch.object(MasterDao, 'list_warehouse', new=AsyncMock(return_value=warehouses)) as list_warehouse,
patch.object(AccessDao, 'list_user_warehouse_ids', new=AsyncMock(return_value=[2, 3])),
):
actual = await InboundService.get_warehouse_options_services(self.db, self.user)
actual = await InboundService.get_warehouse_options_services(self.db, self.user, TestBatchScope.formal())
query = list_warehouse.await_args.args[1]
self.assertEqual('0', query.status)
self.assertIs(False, list_warehouse.await_args.args[2])
self.assertEqual(TestBatchScope.formal(), list_warehouse.await_args.args[2])
self.assertIs(False, list_warehouse.await_args.args[3])
self.assertEqual([BusinessOptionModel(id=2, code='W2', name='二仓')], actual)
self.assertEqual({'id', 'code', 'name'}, set(BusinessOptionModel.model_fields))
@@ -896,7 +857,7 @@ class TestInboundReadService(unittest.IsolatedAsyncioTestCase):
patch.object(MasterDao, 'list_warehouse', new=AsyncMock(return_value=warehouses)),
patch.object(AccessDao, 'list_user_warehouse_ids', new=scope),
):
actual = await InboundService.get_warehouse_options_services(self.db, make_user(1))
actual = await InboundService.get_warehouse_options_services(self.db, make_user(1), TestBatchScope.formal())
scope.assert_not_awaited()
self.assertEqual([2, 5], [option.id for option in actual])
@@ -914,7 +875,7 @@ class TestInboundReadService(unittest.IsolatedAsyncioTestCase):
patch.object(MasterDao, 'list_warehouse', new=AsyncMock(return_value=warehouses)),
patch.object(AccessDao, 'list_user_warehouse_ids', new=AsyncMock(return_value=[2])),
):
actual = await InboundService.get_warehouse_options_services(self.db, self.user)
actual = await InboundService.get_warehouse_options_services(self.db, self.user, TestBatchScope.formal())
self.assertEqual([BusinessOptionModel(id=2, code='W2', name='二仓')], actual)
@@ -945,11 +906,12 @@ class TestInboundScanService(unittest.IsolatedAsyncioTestCase):
'persisted-token',
self.query,
self.user,
TestBatchScope.formal(),
)
access.assert_awaited_once_with(self.db, self.user, 7)
get_pallet.assert_awaited_once_with(self.db, 'persisted-token')
get_inventory.assert_awaited_once_with(self.db, 2)
get_pallet.assert_awaited_once_with(self.db, 'persisted-token', TestBatchScope.formal())
get_inventory.assert_awaited_once_with(self.db, 2, TestBatchScope.formal())
locking_read.assert_not_awaited()
add_event.assert_not_awaited()
self.db.commit.assert_not_awaited()
@@ -987,6 +949,7 @@ class TestInboundScanService(unittest.IsolatedAsyncioTestCase):
'persisted-token',
self.query,
self.user,
TestBatchScope.formal(),
)
async def test_scan_rejects_unauthorized_disabled_or_missing_target_warehouse_first(self) -> None:
@@ -1001,7 +964,9 @@ class TestInboundScanService(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'get_pallet_by_qr_token', new=get_pallet),
self.assertRaises(PermissionException),
):
await InboundService.scan_inbound_pallet_services(self.db, 'token', self.query, self.user)
await InboundService.scan_inbound_pallet_services(
self.db, 'token', self.query, self.user, TestBatchScope.formal()
)
get_pallet.assert_not_awaited()
for warehouse in (None, SimpleNamespace(warehouse_id=7, status='1')):
@@ -1013,7 +978,9 @@ class TestInboundScanService(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'get_pallet_by_qr_token', new=get_pallet),
self.assertRaises(ServiceException),
):
await InboundService.scan_inbound_pallet_services(self.db, 'token', self.query, self.user)
await InboundService.scan_inbound_pallet_services(
self.db, 'token', self.query, self.user, TestBatchScope.formal()
)
get_pallet.assert_not_awaited()
@@ -1045,12 +1012,14 @@ class TestInboundConfirmService(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'get_inventories_for_update', new=inventory_lock),
self.assertRaises(Exception) as raised,
):
await InboundService.confirm_inbound_services(self.db, 404, self.command, self.user)
await InboundService.confirm_inbound_services(
self.db, 404, self.command, self.user, TestBatchScope.formal()
)
self.assertIsInstance(raised.exception, PermissionException)
self.assertEqual('无权访问该入库单', raised.exception.message)
scope.assert_awaited_once_with(self.db, 7)
get_detail.assert_awaited_once_with(self.db, 404, warehouse_ids=[7])
get_detail.assert_awaited_once_with(self.db, 404, TestBatchScope.formal(), warehouse_ids=[7])
get_by_key.assert_not_awaited()
lock_order.assert_not_awaited()
inventory_lock.assert_not_awaited()
@@ -1068,11 +1037,13 @@ class TestInboundConfirmService(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'get_inbound_for_update', new=lock_order),
self.assertRaises(ServiceException) as raised,
):
await InboundService.confirm_inbound_services(self.db, 404, self.command, make_user(1))
await InboundService.confirm_inbound_services(
self.db, 404, self.command, make_user(1), TestBatchScope.formal()
)
self.assertEqual('入库单不存在', raised.exception.message)
scope.assert_not_awaited()
get_detail.assert_awaited_once_with(self.db, 404, warehouse_ids=None)
get_detail.assert_awaited_once_with(self.db, 404, TestBatchScope.formal(), warehouse_ids=None)
get_by_key.assert_not_awaited()
lock_order.assert_not_awaited()
self.db.rollback.assert_awaited_once()
@@ -1169,7 +1140,9 @@ class TestInboundConfirmService(unittest.IsolatedAsyncioTestCase):
patches[10] as warehouse_lock,
):
service_datetime.now.return_value = self.fixed_time
result = await InboundService.confirm_inbound_services(self.db, 11, self.command, self.user)
result = await InboundService.confirm_inbound_services(
self.db, 11, self.command, self.user, TestBatchScope.formal()
)
return {
'result': result,
@@ -1209,17 +1182,33 @@ class TestInboundConfirmService(unittest.IsolatedAsyncioTestCase):
captured['actions'],
)
self.default_scope.assert_awaited_once_with(self.db, 7)
captured['detail_read'].assert_awaited_once_with(self.db, 11, warehouse_ids=[7])
captured['detail_read'].assert_awaited_once_with(
self.db,
11,
TestBatchScope.formal(),
warehouse_ids=[7],
)
captured['key_read'].assert_awaited_once_with(
self.db,
'confirm-key',
TestBatchScope.formal(),
warehouse_ids=[7],
)
captured['order_lock'].assert_awaited_once_with(self.db, 11, warehouse_ids=[7])
captured['warehouse_lock'].assert_awaited_once_with(self.db, 7, for_update=True)
captured['order_lock'].assert_awaited_once_with(
self.db,
11,
TestBatchScope.formal(),
warehouse_ids=[7],
)
captured['warehouse_lock'].assert_awaited_once_with(
self.db,
7,
TestBatchScope.formal(),
for_update=True,
)
captured['access_probe'].assert_awaited_once_with(self.db, self.user, 7, for_update=True)
captured['inventory_lock'].assert_awaited_once_with(self.db, [2, 5])
captured['pallet_lock'].assert_awaited_once_with(self.db, [2, 5])
captured['inventory_lock'].assert_awaited_once_with(self.db, [2, 5], TestBatchScope.formal())
captured['pallet_lock'].assert_awaited_once_with(self.db, [2, 5], TestBatchScope.formal())
captured['ensure_transition'].assert_has_calls(
[
unittest.mock.call(PalletFlowState.UNSTOCKED, PalletFlowState.EMPTY_IN_WAREHOUSE),
@@ -1299,10 +1288,10 @@ class TestInboundConfirmService(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'add_event', new=add_event),
self.assertRaises(PermissionException) as raised,
):
await InboundService.confirm_inbound_services(self.db, 11, self.command, self.user)
await InboundService.confirm_inbound_services(self.db, 11, self.command, self.user, TestBatchScope.formal())
self.assertEqual('无权访问该入库单', raised.exception.message)
warehouse_lock.assert_awaited_once_with(self.db, 7, for_update=True)
warehouse_lock.assert_awaited_once_with(self.db, 7, TestBatchScope.formal(), for_update=True)
warehouse_mapping.assert_awaited_once_with(self.db, self.user, 7, for_update=True)
self.assertEqual('DRAFT', inbound.status)
self.assertEqual('UNSTOCKED', inventory.flow_state)
@@ -1328,9 +1317,9 @@ class TestInboundConfirmService(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'add_event', new=add_event),
self.assertRaises(ServiceException),
):
await InboundService.confirm_inbound_services(self.db, 11, self.command, self.user)
await InboundService.confirm_inbound_services(self.db, 11, self.command, self.user, TestBatchScope.formal())
pallet_lock.assert_awaited_once_with(self.db, [2, 5])
pallet_lock.assert_awaited_once_with(self.db, [2, 5], TestBatchScope.formal())
self.assertEqual('DRAFT', inbound.status)
self.assertEqual('UNSTOCKED', inventories[0].flow_state)
update.assert_not_awaited()
@@ -1360,7 +1349,7 @@ class TestInboundConfirmService(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'add_event', new=add_event),
self.assertRaisesRegex(ValueError, 'invalid'),
):
await InboundService.confirm_inbound_services(self.db, 11, self.command, self.user)
await InboundService.confirm_inbound_services(self.db, 11, self.command, self.user, TestBatchScope.formal())
self.assertEqual('DRAFT', inbound.status)
self.assertEqual('UNSTOCKED', inventory.flow_state)
@@ -1391,10 +1380,12 @@ class TestInboundConfirmService(unittest.IsolatedAsyncioTestCase):
new=AsyncMock(return_value=SimpleNamespace(warehouse_id=7, status='0')),
) as warehouse_lock,
):
result = await InboundService.confirm_inbound_services(self.db, 11, self.command, self.user)
result = await InboundService.confirm_inbound_services(
self.db, 11, self.command, self.user, TestBatchScope.formal()
)
lock.assert_awaited_once_with(self.db, 11, warehouse_ids=[7])
warehouse_lock.assert_awaited_once_with(self.db, 7, for_update=True)
lock.assert_awaited_once_with(self.db, 11, TestBatchScope.formal(), warehouse_ids=[7])
warehouse_lock.assert_awaited_once_with(self.db, 7, TestBatchScope.formal(), for_update=True)
self.assertEqual(
[
unittest.mock.call(self.db, self.user, 7),
@@ -1424,6 +1415,7 @@ class TestInboundConfirmService(unittest.IsolatedAsyncioTestCase):
async def read_key(
_db: AsyncSession,
_key: str,
_scope: TestBatchScope,
*,
warehouse_ids: list[int] | None = None,
) -> BizInboundOrder | None:
@@ -1455,13 +1447,15 @@ class TestInboundConfirmService(unittest.IsolatedAsyncioTestCase):
11,
self.command,
self.user,
TestBatchScope.formal(),
)
self.assertTrue(result.is_success)
get_detail.assert_awaited_once_with(self.db, 11, warehouse_ids=[7, 8])
get_detail.assert_awaited_once_with(self.db, 11, TestBatchScope.formal(), warehouse_ids=[7, 8])
key_read.assert_awaited_once_with(
self.db,
'confirm-key',
TestBatchScope.formal(),
warehouse_ids=[7],
)
self.db.rollback.assert_awaited_once()
@@ -1496,10 +1490,10 @@ class TestInboundConfirmService(unittest.IsolatedAsyncioTestCase):
patch.object(AccessService, 'assert_warehouse_access', new=warehouse_mapping),
self.assertRaises(PermissionException) as raised,
):
await InboundService.confirm_inbound_services(self.db, 11, self.command, self.user)
await InboundService.confirm_inbound_services(self.db, 11, self.command, self.user, TestBatchScope.formal())
self.assertEqual('无权访问该入库单', raised.exception.message)
warehouse_lock.assert_awaited_once_with(self.db, 7, for_update=True)
warehouse_lock.assert_awaited_once_with(self.db, 7, TestBatchScope.formal(), for_update=True)
warehouse_mapping.assert_awaited_with(self.db, self.user, 7, for_update=True)
inventory_lock.assert_not_awaited()
self.db.commit.assert_not_awaited()
@@ -1526,7 +1520,7 @@ class TestInboundConfirmService(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'get_inbound_for_update', new=lock),
self.assertRaises(ServiceException),
):
await InboundService.confirm_inbound_services(self.db, 11, self.command, self.user)
await InboundService.confirm_inbound_services(self.db, 11, self.command, self.user, TestBatchScope.formal())
access.assert_awaited_once_with(self.db, self.user, 8)
lock.assert_not_awaited()
@@ -1548,7 +1542,7 @@ class TestInboundConfirmService(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'get_inventories_for_update', new=inventory_lock),
self.assertRaises(ServiceException),
):
await InboundService.confirm_inbound_services(self.db, 11, self.command, self.user)
await InboundService.confirm_inbound_services(self.db, 11, self.command, self.user, TestBatchScope.formal())
inventory_lock.assert_not_awaited()
self.db.rollback.assert_awaited_once()
@@ -1574,10 +1568,12 @@ class TestInboundConfirmService(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'update_inbound', new=AsyncMock()),
patch.object(InventoryDao, 'add_event', new=AsyncMock()),
):
result = await InboundService.confirm_inbound_services(self.db, 11, self.command, self.user)
result = await InboundService.confirm_inbound_services(
self.db, 11, self.command, self.user, TestBatchScope.formal()
)
get_detail.assert_awaited_once_with(self.db, 11, warehouse_ids=[7])
inventory_lock.assert_awaited_once_with(self.db, [5])
get_detail.assert_awaited_once_with(self.db, 11, TestBatchScope.formal(), warehouse_ids=[7])
inventory_lock.assert_awaited_once_with(self.db, [5], TestBatchScope.formal())
self.assertEqual('EMPTY_IN_WAREHOUSE', inventory.flow_state)
self.assertTrue(result.is_success)
@@ -1608,7 +1604,9 @@ class TestInboundConfirmService(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'update_inbound', new=AsyncMock()),
patch.object(InventoryDao, 'add_event', new=AsyncMock()),
):
result = await InboundService.confirm_inbound_services(self.db, 11, self.command, self.user)
result = await InboundService.confirm_inbound_services(
self.db, 11, self.command, self.user, TestBatchScope.formal()
)
self.assertEqual(2, parent_lock.await_count)
self.assertEqual(
@@ -1621,8 +1619,8 @@ class TestInboundConfirmService(unittest.IsolatedAsyncioTestCase):
self.assertEqual(2, key_reads.await_count)
key_reads.assert_has_awaits(
[
unittest.mock.call(self.db, 'confirm-key', warehouse_ids=[7]),
unittest.mock.call(self.db, 'confirm-key', warehouse_ids=[7]),
unittest.mock.call(self.db, 'confirm-key', TestBatchScope.formal(), warehouse_ids=[7]),
unittest.mock.call(self.db, 'confirm-key', TestBatchScope.formal(), warehouse_ids=[7]),
]
)
self.assertEqual(2, self.db.rollback.await_count)
@@ -1647,6 +1645,7 @@ class TestInboundConfirmService(unittest.IsolatedAsyncioTestCase):
async def read_key(
_db: AsyncSession,
_key: str,
_scope: TestBatchScope,
*,
warehouse_ids: list[int] | None = None,
) -> BizInboundOrder | None:
@@ -1683,6 +1682,7 @@ class TestInboundConfirmService(unittest.IsolatedAsyncioTestCase):
11,
self.command,
self.user,
TestBatchScope.formal(),
)
self.assertTrue(result.is_success)
@@ -1690,8 +1690,8 @@ class TestInboundConfirmService(unittest.IsolatedAsyncioTestCase):
self.assertEqual(2, parent_lock.await_count)
self.assertEqual(
[
unittest.mock.call(self.db, 'confirm-key', warehouse_ids=[7]),
unittest.mock.call(self.db, 'confirm-key', warehouse_ids=[7]),
unittest.mock.call(self.db, 'confirm-key', TestBatchScope.formal(), warehouse_ids=[7]),
unittest.mock.call(self.db, 'confirm-key', TestBatchScope.formal(), warehouse_ids=[7]),
],
key_read.await_args_list,
)
@@ -1743,11 +1743,11 @@ class TestInboundConfirmService(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'add_event', new=AsyncMock()),
self.assertRaises(PermissionException) as raised,
):
await InboundService.confirm_inbound_services(self.db, 11, self.command, self.user)
await InboundService.confirm_inbound_services(self.db, 11, self.command, self.user, TestBatchScope.formal())
self.assertEqual('无权访问该入库单', raised.exception.message)
self.assertEqual(2, parent_lock.await_count)
parent_lock.assert_awaited_with(self.db, 11, warehouse_ids=[7])
parent_lock.assert_awaited_with(self.db, 11, TestBatchScope.formal(), warehouse_ids=[7])
self.assertEqual(2, warehouse_lock.await_count)
self.assertEqual(2, locked_access_count)
self.assertEqual(2, self.db.rollback.await_count)
@@ -1782,7 +1782,7 @@ class TestInboundConfirmService(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'add_event', new=AsyncMock()),
self.assertRaises(ServiceException),
):
await InboundService.confirm_inbound_services(self.db, 11, self.command, self.user)
await InboundService.confirm_inbound_services(self.db, 11, self.command, self.user, TestBatchScope.formal())
self.assertEqual(2, self.db.rollback.await_count)
@@ -1836,6 +1836,7 @@ class TestInboundLogPermission(unittest.IsolatedAsyncioTestCase):
add_inbound=InboundCreateModel(warehouseId=404, palletIds=[2]),
query_db=db,
current_user=user,
test_scope=TestBatchScope.formal(),
)
finally:
RequestContext.reset_current_user(user_token)
shierfeng-fastapi-backend/tests/module_business/test_inventory_dao.py
+73 -45
View File
@@ -13,6 +13,7 @@ from module_business.dao import inventory_dao as inventory_dao_module
from module_business.dao import operation_dao as operation_dao_module
from module_business.dao.inventory_dao import InventoryDao
from module_business.dao.operation_dao import OperationDao
from module_business.domain.test_batch_scope import TestBatchScope
from module_business.entity.do.master_do import BizPallet
from module_business.entity.do.operation_do import (
BizFillingRecord,
@@ -66,11 +67,11 @@ class TestDaoPublicContract(unittest.TestCase):
def test_inventory_dao_critical_parameter_names_are_stable(self) -> None:
expected = {
'get_inventory_for_update': ('db', 'pallet_id'),
'get_inventories_for_update': ('db', 'pallet_ids'),
'get_pallet_by_qr_token': ('db', 'qr_token'),
'get_pallets_by_ids': ('db', 'pallet_ids'),
'get_event_by_idempotency_key': ('db', 'pallet_id', 'idempotency_key'),
'get_inventory_for_update': ('db', 'pallet_id', 'scope'),
'get_inventories_for_update': ('db', 'pallet_ids', 'scope'),
'get_pallet_by_qr_token': ('db', 'qr_token', 'scope'),
'get_pallets_by_ids': ('db', 'pallet_ids', 'scope'),
'get_event_by_idempotency_key': ('db', 'pallet_id', 'idempotency_key', 'scope'),
'add_event': ('db', 'inventory', 'event'),
}
for method_name, parameter_names in expected.items():
@@ -121,51 +122,55 @@ class TestDaoPublicContract(unittest.TestCase):
def test_operation_dao_critical_parameter_names_and_defaults_are_stable(self) -> None:
expected = {
'get_inbound_for_update': ('db', 'inbound_id', 'warehouse_ids'),
'get_shipment_for_update': ('db', 'shipment_id', 'warehouse_ids', 'site_ids'),
'get_return_for_update': ('db', 'return_id', 'site_ids', 'warehouse_ids'),
'get_active_filling_for_update': ('db', 'filling_id'),
'get_inbound_for_update': ('db', 'inbound_id', 'scope', 'warehouse_ids'),
'get_shipment_for_update': ('db', 'shipment_id', 'scope', 'warehouse_ids', 'site_ids'),
'get_return_for_update': ('db', 'return_id', 'scope', 'site_ids', 'warehouse_ids'),
'get_active_filling_for_update': ('db', 'filling_id', 'scope'),
'get_inbound_by_confirm_idempotency_key': (
'db',
'idempotency_key',
'scope',
'warehouse_ids',
),
'get_shipment_by_confirm_idempotency_key': (
'db',
'idempotency_key',
'scope',
'warehouse_ids',
'site_ids',
),
'get_filling_by_idempotency_key': ('db', 'idempotency_key', 'warehouse_ids'),
'get_usage_by_idempotency_key': ('db', 'idempotency_key', 'site_ids'),
'get_filling_by_idempotency_key': ('db', 'idempotency_key', 'scope', 'warehouse_ids'),
'get_usage_by_idempotency_key': ('db', 'idempotency_key', 'scope', 'site_ids'),
'get_return_by_request_idempotency_key': (
'db',
'idempotency_key',
'source_site_id',
'target_warehouse_id',
'scope',
),
'get_return_by_confirm_idempotency_key': (
'db',
'idempotency_key',
'source_site_id',
'target_warehouse_id',
'scope',
),
'get_inbound_by_id': ('db', 'inbound_id', 'warehouse_ids'),
'get_inbound_by_id': ('db', 'inbound_id', 'scope', 'warehouse_ids'),
'add_inbound': ('db', 'inbound'),
'update_inbound': ('db', 'inbound'),
'delete_inbound': ('db', 'inbound_id'),
'replace_inbound_items': ('db', 'inbound_id', 'items'),
'get_filling_by_id': ('db', 'filling_id', 'warehouse_ids'),
'get_filling_by_id': ('db', 'filling_id', 'scope', 'warehouse_ids'),
'add_filling_record': ('db', 'filling'),
'update_filling_record': ('db', 'filling'),
'get_shipment_by_id': ('db', 'shipment_id', 'warehouse_ids', 'site_ids'),
'get_shipment_by_id': ('db', 'shipment_id', 'scope', 'warehouse_ids', 'site_ids'),
'add_shipment': ('db', 'shipment'),
'update_shipment': ('db', 'shipment'),
'delete_shipment': ('db', 'shipment_id'),
'replace_shipment_items': ('db', 'shipment_id', 'items'),
'get_usage_by_id': ('db', 'usage_id', 'site_ids'),
'get_usage_by_id': ('db', 'usage_id', 'scope', 'site_ids'),
'add_usage_record': ('db', 'usage'),
'get_return_by_id': ('db', 'return_id', 'site_ids', 'warehouse_ids'),
'get_return_by_id': ('db', 'return_id', 'scope', 'site_ids', 'warehouse_ids'),
'add_return_order': ('db', 'return_order'),
'update_return_order': ('db', 'return_order'),
'add_return_items': ('db', 'items'),
@@ -177,11 +182,10 @@ class TestDaoPublicContract(unittest.TestCase):
inbound_list_signature = inspect.signature(OperationDao.get_inbound_list)
self.assertEqual(
('db', 'query_object', 'is_page', 'warehouse_ids'),
('db', 'query_object', 'warehouse_ids', 'scope', 'is_page'),
tuple(inbound_list_signature.parameters),
)
self.assertIs(True, inbound_list_signature.parameters['is_page'].default)
self.assertIsNone(inbound_list_signature.parameters['warehouse_ids'].default)
for method_name in (
'get_inbound_for_update',
@@ -208,28 +212,24 @@ class TestDaoPublicContract(unittest.TestCase):
filling_list_signature = inspect.signature(OperationDao.get_filling_list)
self.assertEqual(
('db', 'query_object', 'is_page', 'warehouse_ids'),
('db', 'query_object', 'warehouse_ids', 'scope', 'is_page'),
tuple(filling_list_signature.parameters),
)
self.assertIs(True, filling_list_signature.parameters['is_page'].default)
self.assertIsNone(filling_list_signature.parameters['warehouse_ids'].default)
shipment_list_signature = inspect.signature(OperationDao.get_shipment_list)
self.assertEqual(
('db', 'query_object', 'is_page', 'warehouse_ids', 'site_ids'),
('db', 'query_object', 'warehouse_ids', 'site_ids', 'scope', 'is_page'),
tuple(shipment_list_signature.parameters),
)
self.assertIs(True, shipment_list_signature.parameters['is_page'].default)
self.assertIsNone(shipment_list_signature.parameters['warehouse_ids'].default)
self.assertIsNone(shipment_list_signature.parameters['site_ids'].default)
usage_list_signature = inspect.signature(OperationDao.get_usage_list)
self.assertEqual(
('db', 'query_object', 'is_page', 'site_ids'),
('db', 'query_object', 'site_ids', 'scope', 'is_page'),
tuple(usage_list_signature.parameters),
)
self.assertIs(True, usage_list_signature.parameters['is_page'].default)
self.assertIsNone(usage_list_signature.parameters['site_ids'].default)
for method_name in (
'get_usage_by_idempotency_key',
@@ -243,14 +243,13 @@ class TestDaoPublicContract(unittest.TestCase):
return_list_signature = inspect.signature(OperationDao.get_return_list)
self.assertEqual(
('db', 'query_object', 'is_page', 'site_ids', 'warehouse_ids'),
('db', 'query_object', 'site_ids', 'warehouse_ids', 'scope', 'is_page'),
tuple(return_list_signature.parameters),
)
self.assertIs(True, return_list_signature.parameters['is_page'].default)
for method_name in (
'get_return_for_update',
'get_return_by_id',
'get_return_list',
):
with self.subTest(method=method_name):
signature = inspect.signature(getattr(OperationDao, method_name))
@@ -284,7 +283,7 @@ class TestInventoryDao(unittest.IsolatedAsyncioTestCase):
result.scalar_one_or_none.return_value = inventory
self.db.execute.return_value = result
actual = await InventoryDao.get_inventory_for_update(self.db, pallet_id=7)
actual = await InventoryDao.get_inventory_for_update(self.db, pallet_id=7, scope=TestBatchScope.formal())
self.assertIs(inventory, actual)
statement = self.db.execute.await_args.args[0]
@@ -305,7 +304,7 @@ class TestInventoryDao(unittest.IsolatedAsyncioTestCase):
result.scalars.return_value.all.return_value = inventories
self.db.execute.return_value = result
actual = await InventoryDao.get_inventories_for_update(self.db, [9, 2, 5, 2])
actual = await InventoryDao.get_inventories_for_update(self.db, [9, 2, 5, 2], scope=TestBatchScope.formal())
self.assertEqual([2, 5, 9], [inventory.pallet_id for inventory in actual])
statement = self.db.execute.await_args.args[0]
@@ -318,7 +317,7 @@ class TestInventoryDao(unittest.IsolatedAsyncioTestCase):
self.assertIn('FOR UPDATE', sql)
async def test_get_inventories_for_update_empty_input_skips_sql(self) -> None:
self.assertEqual([], await InventoryDao.get_inventories_for_update(self.db, []))
self.assertEqual([], await InventoryDao.get_inventories_for_update(self.db, [], scope=TestBatchScope.formal()))
self.db.execute.assert_not_awaited()
async def test_get_pallet_by_qr_token_uses_exact_token_without_lock(self) -> None:
@@ -327,7 +326,9 @@ class TestInventoryDao(unittest.IsolatedAsyncioTestCase):
result.scalar_one_or_none.return_value = pallet
self.db.execute.return_value = result
actual = await InventoryDao.get_pallet_by_qr_token(self.db, qr_token='fixed-token')
actual = await InventoryDao.get_pallet_by_qr_token(
self.db, qr_token='fixed-token', scope=TestBatchScope.formal()
)
self.assertIs(pallet, actual)
statement = self.db.execute.await_args.args[0]
@@ -346,7 +347,7 @@ class TestInventoryDao(unittest.IsolatedAsyncioTestCase):
result.scalars.return_value.all.return_value = pallets
self.db.execute.return_value = result
actual = await InventoryDao.get_pallets_by_ids(self.db, [9, 2, 5, 2])
actual = await InventoryDao.get_pallets_by_ids(self.db, [9, 2, 5, 2], scope=TestBatchScope.formal())
self.assertEqual([2, 5, 9], [pallet.pallet_id for pallet in actual])
statement = self.db.execute.await_args.args[0]
@@ -359,7 +360,7 @@ class TestInventoryDao(unittest.IsolatedAsyncioTestCase):
self.assertIn('FOR UPDATE', sql)
async def test_get_pallets_by_ids_empty_input_skips_sql(self) -> None:
self.assertEqual([], await InventoryDao.get_pallets_by_ids(self.db, []))
self.assertEqual([], await InventoryDao.get_pallets_by_ids(self.db, [], scope=TestBatchScope.formal()))
self.db.execute.assert_not_awaited()
async def test_get_event_by_idempotency_key_uses_pallet_scoped_key(self) -> None:
@@ -372,6 +373,7 @@ class TestInventoryDao(unittest.IsolatedAsyncioTestCase):
self.db,
pallet_id=7,
idempotency_key='event-key',
scope=TestBatchScope.formal(),
)
self.assertIs(event, actual)
@@ -474,7 +476,7 @@ class TestOperationDaoReads(unittest.IsolatedAsyncioTestCase):
result.scalar_one_or_none.return_value = record
self.db.execute.return_value = result
actual = await method(self.db, record_id)
actual = await method(self.db, record_id, scope=TestBatchScope.formal())
self.assertIs(record, actual)
statement = self.db.execute.await_args.args[0]
@@ -504,6 +506,7 @@ class TestOperationDaoReads(unittest.IsolatedAsyncioTestCase):
12,
warehouse_ids=[7, 3, 7],
site_ids=[11, 9, 11],
scope=TestBatchScope.formal(),
)
self.assertIs(shipment, actual)
@@ -540,6 +543,7 @@ class TestOperationDaoReads(unittest.IsolatedAsyncioTestCase):
12,
warehouse_ids=[],
site_ids=[9],
scope=TestBatchScope.formal(),
)
self.assertIsNone(actual)
@@ -562,7 +566,7 @@ class TestOperationDaoReads(unittest.IsolatedAsyncioTestCase):
item_result.scalars.return_value.all.return_value = items
self.db.execute.side_effect = [inbound_result, item_result]
actual = await OperationDao.get_inbound_for_update(self.db, inbound_id=11)
actual = await OperationDao.get_inbound_for_update(self.db, inbound_id=11, scope=TestBatchScope.formal())
self.assertIs(inbound, actual)
self.assertEqual(items, actual.items)
@@ -599,6 +603,7 @@ class TestOperationDaoReads(unittest.IsolatedAsyncioTestCase):
self.db,
inbound_id=11,
warehouse_ids=[7, 3, 7],
scope=TestBatchScope.formal(),
)
self.assertIsNone(actual)
@@ -647,7 +652,7 @@ class TestOperationDaoReads(unittest.IsolatedAsyncioTestCase):
result.scalar_one_or_none.return_value = record
self.db.execute.return_value = result
actual = await method(self.db, 'same-key', **kwargs)
actual = await method(self.db, 'same-key', scope=TestBatchScope.formal(), **kwargs)
self.assertIs(record, actual)
statement = self.db.execute.await_args.args[0]
@@ -673,6 +678,7 @@ class TestOperationDaoReads(unittest.IsolatedAsyncioTestCase):
self.db,
'confirm-key',
warehouse_ids=[7, 3, 7],
scope=TestBatchScope.formal(),
)
self.assertIsNone(actual)
@@ -807,7 +813,16 @@ class TestOperationDaoReads(unittest.IsolatedAsyncioTestCase):
marker = object()
is_page = index % 2 == 0
with patch.object(PageUtil, 'paginate', new=AsyncMock(return_value=marker)) as paginate:
actual = await method(self.db, query, is_page=is_page)
kwargs = {
'scope': TestBatchScope.formal(),
'is_page': is_page,
}
parameters = inspect.signature(method).parameters
if 'warehouse_ids' in parameters:
kwargs['warehouse_ids'] = None
if 'site_ids' in parameters:
kwargs['site_ids'] = None
actual = await method(self.db, query, **kwargs)
self.assertIs(marker, actual)
args = paginate.await_args.args
@@ -829,6 +844,7 @@ class TestOperationDaoReads(unittest.IsolatedAsyncioTestCase):
query,
is_page=True,
warehouse_ids=[5, 2, 5],
scope=TestBatchScope.formal(),
)
self.assertIs(marker, actual)
@@ -848,6 +864,7 @@ class TestOperationDaoReads(unittest.IsolatedAsyncioTestCase):
query,
is_page=True,
warehouse_ids=[],
scope=TestBatchScope.formal(),
)
self.assertIs(marker, actual)
@@ -866,6 +883,7 @@ class TestOperationDaoReads(unittest.IsolatedAsyncioTestCase):
query,
is_page=True,
warehouse_ids=None,
scope=TestBatchScope.formal(),
)
sql = compile_sql(paginate.await_args.args[1])
@@ -882,6 +900,7 @@ class TestOperationDaoReads(unittest.IsolatedAsyncioTestCase):
is_page=True,
warehouse_ids=[7, 3, 7],
site_ids=[11, 9, 11],
scope=TestBatchScope.formal(),
)
self.assertIs(marker, actual)
@@ -898,6 +917,7 @@ class TestOperationDaoReads(unittest.IsolatedAsyncioTestCase):
query,
warehouse_ids=[7],
site_ids=[],
scope=TestBatchScope.formal(),
)
empty_statement = empty_paginate.await_args.args[1]
self.assertIn('false = 1', compile_sql(empty_statement, mysql.dialect()))
@@ -914,6 +934,7 @@ class TestOperationDaoReads(unittest.IsolatedAsyncioTestCase):
12,
warehouse_ids=[7, 3],
site_ids=[11, 9],
scope=TestBatchScope.formal(),
)
)
self.db.execute.assert_awaited_once()
@@ -927,6 +948,7 @@ class TestOperationDaoReads(unittest.IsolatedAsyncioTestCase):
'confirm-key',
warehouse_ids=[7, 3],
site_ids=[11, 9],
scope=TestBatchScope.formal(),
)
)
key_statement = self.db.execute.await_args.args[0]
@@ -949,6 +971,7 @@ class TestOperationDaoReads(unittest.IsolatedAsyncioTestCase):
query,
is_page=True,
site_ids=[11, 9, 11],
scope=TestBatchScope.formal(),
)
self.assertIs(marker, actual)
@@ -957,7 +980,7 @@ class TestOperationDaoReads(unittest.IsolatedAsyncioTestCase):
scalar_result = MagicMock()
scalar_result.scalar_one_or_none.return_value = None
self.db.execute.return_value = scalar_result
await OperationDao.get_usage_by_id(self.db, 15, site_ids=[11, 9, 11])
await OperationDao.get_usage_by_id(self.db, 15, site_ids=[11, 9, 11], scope=TestBatchScope.formal())
detail_statement = self.db.execute.await_args.args[0]
self.db.reset_mock()
@@ -966,6 +989,7 @@ class TestOperationDaoReads(unittest.IsolatedAsyncioTestCase):
self.db,
'usage-key',
site_ids=[11, 9, 11],
scope=TestBatchScope.formal(),
)
key_statement = self.db.execute.await_args.args[0]
@@ -976,17 +1000,19 @@ class TestOperationDaoReads(unittest.IsolatedAsyncioTestCase):
self.assertIn('biz_usage_record.site_id IN (9, 11)', sql)
with patch.object(PageUtil, 'paginate', new=AsyncMock(return_value=marker)) as empty_paginate:
await OperationDao.get_usage_list(self.db, query, site_ids=[])
await OperationDao.get_usage_list(self.db, query, site_ids=[], scope=TestBatchScope.formal())
empty_list = empty_paginate.await_args.args[1]
self.db.reset_mock()
self.db.execute.return_value = scalar_result
await OperationDao.get_usage_by_id(self.db, 15, site_ids=[])
await OperationDao.get_usage_by_id(self.db, 15, site_ids=[], scope=TestBatchScope.formal())
empty_detail = self.db.execute.await_args.args[0]
self.db.reset_mock()
self.db.execute.return_value = scalar_result
await OperationDao.get_usage_by_idempotency_key(self.db, 'usage-key', site_ids=[])
await OperationDao.get_usage_by_idempotency_key(
self.db, 'usage-key', site_ids=[], scope=TestBatchScope.formal()
)
empty_key = self.db.execute.await_args.args[0]
for dialect in (mysql.dialect(), postgresql.dialect()):
@@ -999,7 +1025,7 @@ class TestOperationDaoReads(unittest.IsolatedAsyncioTestCase):
query = UsagePageQueryModel()
marker = object()
with patch.object(PageUtil, 'paginate', new=AsyncMock(return_value=marker)) as paginate:
await OperationDao.get_usage_list(self.db, query, site_ids=None)
await OperationDao.get_usage_list(self.db, query, site_ids=None, scope=TestBatchScope.formal())
sql = compile_sql(paginate.await_args.args[1])
self.assertNotIn('site_id IN', sql)
@@ -1023,6 +1049,7 @@ class TestOperationDaoReads(unittest.IsolatedAsyncioTestCase):
self.db,
'usage-key',
site_ids=site_ids,
scope=TestBatchScope.formal(),
)
statement = self.db.execute.await_args.args[0]
@@ -1081,7 +1108,7 @@ class TestOperationDaoReads(unittest.IsolatedAsyncioTestCase):
item_result.scalars.return_value.all.return_value = items
self.db.execute.side_effect = [order_result, item_result]
actual = await method(self.db, order_id)
actual = await method(self.db, order_id, scope=TestBatchScope.formal())
self.assertIs(order, actual)
self.assertEqual(items, order.items)
@@ -1102,7 +1129,7 @@ class TestOperationDaoReads(unittest.IsolatedAsyncioTestCase):
result.scalar_one_or_none.return_value = None
self.db.execute.return_value = result
self.assertIsNone(await OperationDao.get_inbound_by_id(self.db, inbound_id=404))
self.assertIsNone(await OperationDao.get_inbound_by_id(self.db, inbound_id=404, scope=TestBatchScope.formal()))
self.db.execute.assert_awaited_once()
@@ -1119,6 +1146,7 @@ class TestOperationDaoReads(unittest.IsolatedAsyncioTestCase):
self.db,
inbound_id=11,
warehouse_ids=[],
scope=TestBatchScope.formal(),
)
self.assertIsNone(actual)
@@ -1142,7 +1170,7 @@ class TestOperationDaoReads(unittest.IsolatedAsyncioTestCase):
result.scalar_one_or_none.return_value = record
self.db.execute.return_value = result
actual = await method(self.db, record_id)
actual = await method(self.db, record_id, scope=TestBatchScope.formal())
self.assertIs(record, actual)
statement = self.db.execute.await_args.args[0]
shierfeng-fastapi-backend/tests/module_business/test_return_service.py
+118 -56
View File
@@ -25,6 +25,7 @@ from module_business.dao.inventory_dao import InventoryDao
from module_business.dao.master_dao import MasterDao
from module_business.dao.operation_dao import OperationDao
from module_business.domain.enums import PalletEventType, PalletFlowState, ReturnStatus
from module_business.domain.test_batch_scope import TestBatchScope
from module_business.entity.do.master_do import BizCustomerSite, BizPallet, BizWarehouse
from module_business.entity.do.operation_do import (
BizFillingRecord,
@@ -184,20 +185,22 @@ class ReturnDaoScopeRedTest(unittest.IsolatedAsyncioTestCase):
def test_return_reads_expose_stage_scopes(self) -> None:
expected = {
OperationDao.get_return_for_update: ('db', 'return_id', 'site_ids', 'warehouse_ids'),
OperationDao.get_return_for_update: ('db', 'return_id', 'scope', 'site_ids', 'warehouse_ids'),
OperationDao.get_return_by_request_idempotency_key: (
'db',
'idempotency_key',
'source_site_id',
'target_warehouse_id',
'scope',
),
OperationDao.get_return_by_confirm_idempotency_key: (
'db',
'idempotency_key',
'source_site_id',
'target_warehouse_id',
'scope',
),
OperationDao.get_return_by_id: ('db', 'return_id', 'site_ids', 'warehouse_ids'),
OperationDao.get_return_by_id: ('db', 'return_id', 'scope', 'site_ids', 'warehouse_ids'),
}
for method, parameters in expected.items():
with self.subTest(method=method.__name__):
@@ -208,7 +211,7 @@ class ReturnDaoScopeRedTest(unittest.IsolatedAsyncioTestCase):
list_signature = inspect.signature(OperationDao.get_return_list)
self.assertEqual(
('db', 'query_object', 'is_page', 'site_ids', 'warehouse_ids'),
('db', 'query_object', 'site_ids', 'warehouse_ids', 'scope', 'is_page'),
tuple(list_signature.parameters),
)
self.assertIs(True, list_signature.parameters['is_page'].default)
@@ -235,6 +238,7 @@ class ReturnDaoScopeRedTest(unittest.IsolatedAsyncioTestCase):
13,
site_ids=[9, 7, 9],
warehouse_ids=[],
scope=TestBatchScope.formal(),
)
self.assertIs(order, actual)
@@ -271,6 +275,7 @@ class ReturnDaoScopeRedTest(unittest.IsolatedAsyncioTestCase):
13,
site_ids=[9],
warehouse_ids=[7],
scope=TestBatchScope.formal(),
)
statement = self.db.execute.await_args.args[0]
@@ -302,6 +307,7 @@ class ReturnDaoScopeRedTest(unittest.IsolatedAsyncioTestCase):
key,
source_site_id=source_site_id,
target_warehouse_id=target_warehouse_id,
scope=TestBatchScope.formal(),
)
statement = self.db.execute.await_args.args[0]
@@ -317,6 +323,18 @@ class ReturnDaoScopeRedTest(unittest.IsolatedAsyncioTestCase):
@unittest.skipUnless(ReturnService is not None, 'ReturnService 尚未实现')
class ReturnServiceContractRedTest(unittest.TestCase):
def test_public_business_methods_require_explicit_test_scope(self) -> None:
for method_name in (
'get_return_list_services',
'return_detail_services',
'get_warehouse_options_services',
'scan_return_pallet_services',
'request_return_services',
'confirm_return_services',
):
with self.subTest(method=method_name):
self.assertIn('test_scope', inspect.signature(getattr(ReturnService, method_name)).parameters)
def test_service_exposes_complete_return_workflow(self) -> None:
expected = {
'get_return_list_services',
@@ -331,9 +349,9 @@ class ReturnServiceContractRedTest(unittest.TestCase):
def test_request_and_confirm_signatures_are_exact(self) -> None:
request_signature = inspect.signature(ReturnService.request_return_services)
confirm_signature = inspect.signature(ReturnService.confirm_return_services)
self.assertEqual(('query_db', 'page_object', 'current_user'), tuple(request_signature.parameters))
self.assertEqual(('query_db', 'page_object', 'current_user', 'test_scope'), tuple(request_signature.parameters))
self.assertEqual(
('query_db', 'return_id', 'page_object', 'current_user'),
('query_db', 'return_id', 'page_object', 'current_user', 'test_scope'),
tuple(confirm_signature.parameters),
)
request_hints = get_type_hints(ReturnService.request_return_services)
@@ -493,15 +511,16 @@ class ReturnReadAndScanRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(AccessDao, 'list_user_warehouse_ids', new=AsyncMock(return_value=[7, 7])),
patch.object(OperationDao, 'get_return_list', new=AsyncMock(return_value=page)) as get_list,
):
actual = await ReturnService.get_return_list_services(self.db, query, self.user)
actual = await ReturnService.get_return_list_services(self.db, query, self.user, TestBatchScope.formal())
self.assertEqual([], actual.rows)
get_list.assert_awaited_once_with(
self.db,
query,
True,
site_ids=[9],
warehouse_ids=[7],
scope=TestBatchScope.formal(),
is_page=True,
)
with (
@@ -509,7 +528,7 @@ class ReturnReadAndScanRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(AccessDao, 'list_user_warehouse_ids', new=AsyncMock(return_value=[])),
patch.object(OperationDao, 'get_return_list', new=AsyncMock()) as empty_get_list,
):
empty = await ReturnService.get_return_list_services(self.db, query, self.user)
empty = await ReturnService.get_return_list_services(self.db, query, self.user, TestBatchScope.formal())
self.assertEqual([], empty.rows)
empty_get_list.assert_not_awaited()
@@ -523,7 +542,7 @@ class ReturnReadAndScanRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(MasterDao, 'list_warehouse', new=AsyncMock(return_value=warehouses)),
patch.object(AccessDao, 'list_user_warehouse_ids', new=AsyncMock()) as mappings,
):
actual = await ReturnService.get_warehouse_options_services(self.db, self.user)
actual = await ReturnService.get_warehouse_options_services(self.db, self.user, TestBatchScope.formal())
self.assertEqual([3, 7], [option.id for option in actual])
mappings.assert_not_awaited()
@@ -543,10 +562,11 @@ class ReturnReadAndScanRedTest(unittest.IsolatedAsyncioTestCase):
' qr-2 ',
ReturnScanQueryModel(mode='request'),
self.user,
TestBatchScope.formal(),
)
get_pallet.assert_awaited_once_with(self.db, 'qr-2')
get_inventory.assert_awaited_once_with(self.db, 2)
get_pallet.assert_awaited_once_with(self.db, 'qr-2', TestBatchScope.formal())
get_inventory.assert_awaited_once_with(self.db, 2, TestBatchScope.formal())
site_access.assert_awaited_once_with(self.db, self.user, 9)
self.assertEqual(PalletFlowState.AT_SITE_PARTIAL, actual.flow_state)
self.assertEqual(8, actual.remaining_packages)
@@ -569,9 +589,10 @@ class ReturnReadAndScanRedTest(unittest.IsolatedAsyncioTestCase):
'qr-2',
ReturnScanQueryModel(mode='confirm', returnId=13),
self.user,
TestBatchScope.formal(),
)
get_order.assert_awaited_once_with(self.db, 13, site_ids=[], warehouse_ids=[7])
get_order.assert_awaited_once_with(self.db, 13, TestBatchScope.formal(), site_ids=[], warehouse_ids=[7])
self.assertEqual(PalletFlowState.RETURNING, actual.flow_state)
self.assertEqual(['confirm'], actual.allowed_actions)
@@ -586,7 +607,7 @@ class ReturnReadAndScanRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(MasterDao, 'get_pallet_inventory', new=AsyncMock(return_value=changed)),
self.assertRaises(ServiceException) as changed_error,
):
await ReturnService.scan_return_pallet_services(self.db, 'qr-2', query, self.user)
await ReturnService.scan_return_pallet_services(self.db, 'qr-2', query, self.user, TestBatchScope.formal())
self.assertIn('快照', changed_error.exception.message)
with (
@@ -594,7 +615,7 @@ class ReturnReadAndScanRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'get_return_by_id', new=AsyncMock(return_value=None)),
self.assertRaises(PermissionException) as hidden_error,
):
await ReturnService.scan_return_pallet_services(self.db, 'qr-2', query, self.user)
await ReturnService.scan_return_pallet_services(self.db, 'qr-2', query, self.user, TestBatchScope.formal())
self.assertEqual('无权访问该退回单', hidden_error.exception.message)
async def test_confirm_scan_hides_missing_and_foreign_pallet_equally_for_normal_user(self) -> None:
@@ -611,7 +632,9 @@ class ReturnReadAndScanRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(MasterDao, 'get_pallet_inventory', new=inventory_read),
):
try:
await ReturnService.scan_return_pallet_services(self.db, 'qr-5', query, self.user)
await ReturnService.scan_return_pallet_services(
self.db, 'qr-5', query, self.user, TestBatchScope.formal()
)
except Exception as exc:
raised = exc
else:
@@ -638,7 +661,9 @@ class ReturnReadAndScanRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(MasterDao, 'get_pallet_inventory', new=AsyncMock()) as inventory_read,
self.assertRaises(ServiceException) as raised,
):
await ReturnService.scan_return_pallet_services(self.db, 'qr-5', query, admin)
await ReturnService.scan_return_pallet_services(
self.db, 'qr-5', query, admin, TestBatchScope.formal()
)
self.assertEqual(expected_message, raised.exception.message)
inventory_read.assert_not_awaited()
@@ -679,11 +704,11 @@ class ReturnRequestTransactionRedTest(unittest.IsolatedAsyncioTestCase):
) as site_access,
patch.object(AccessService, 'assert_warehouse_access', new=warehouse_access),
):
await ReturnService._lock_new_request_route(self.db, self.page, self.user)
await ReturnService._lock_new_request_route(self.db, self.page, self.user, TestBatchScope.formal())
self.assertEqual(['warehouse-row', 'site-row', 'site-mapping'], actions)
warehouse_read.assert_awaited_once_with(self.db, 7, for_update=True)
site_read.assert_awaited_once_with(self.db, 9, for_update=True)
warehouse_read.assert_awaited_once_with(self.db, 7, TestBatchScope.formal(), for_update=True)
site_read.assert_awaited_once_with(self.db, 9, TestBatchScope.formal(), for_update=True)
site_access.assert_awaited_once_with(self.db, self.user, 9, for_update=True)
warehouse_access.assert_not_awaited()
@@ -752,7 +777,9 @@ class ReturnRequestTransactionRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'add_event', new=AsyncMock(side_effect=add_event)),
):
try:
result = await ReturnService.request_return_services(self.db, self.page, self.user)
result = await ReturnService.request_return_services(
self.db, self.page, self.user, TestBatchScope.formal()
)
except RuntimeError as exc:
self.fail(str(exc))
@@ -839,7 +866,9 @@ class ReturnRequestTransactionRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'add_event', new=AsyncMock()) as add_event,
):
try:
result = await ReturnService.request_return_services(self.db, self.page, self.user)
result = await ReturnService.request_return_services(
self.db, self.page, self.user, TestBatchScope.formal()
)
except ServiceException as exc:
self.fail(f'锁等待后的精确重试被库存状态提前拒绝：{exc.message}')
@@ -896,7 +925,7 @@ class ReturnRequestTransactionRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'add_return_order', new=AsyncMock()) as add_order,
self.assertRaises(ServiceException) as raised,
):
await ReturnService.request_return_services(self.db, conflict_page, self.user)
await ReturnService.request_return_services(self.db, conflict_page, self.user, TestBatchScope.formal())
self.assertEqual('申请退回失败，幂等键已被其他请求使用', raised.exception.message)
self.assertEqual(2, key_read.await_count)
@@ -942,7 +971,9 @@ class ReturnRequestTransactionRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'add_event', new=AsyncMock()) as add_event,
):
try:
result = await ReturnService.request_return_services(self.db, self.page, self.user)
result = await ReturnService.request_return_services(
self.db, self.page, self.user, TestBatchScope.formal()
)
except PermissionException as exc:
self.fail(f'已确认赢家在 fresh key 查询前被库存位置提前隐藏：{exc.message}')
@@ -992,7 +1023,7 @@ class ReturnRequestTransactionRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'add_return_order', new=AsyncMock()) as add_order,
):
try:
await ReturnService.request_return_services(self.db, conflict_page, self.user)
await ReturnService.request_return_services(self.db, conflict_page, self.user, TestBatchScope.formal())
except Exception as exc:
raised = exc
else:
@@ -1032,13 +1063,21 @@ class ReturnRequestTransactionRedTest(unittest.IsolatedAsyncioTestCase):
),
patch.object(MasterDao, 'get_site', new=AsyncMock(return_value=SimpleNamespace(status='0'))),
):
result = await ReturnService.request_return_services(self.db, self.page, self.user)
result = await ReturnService.request_return_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertEqual(13, result.result)
self.assertEqual(
[
{'source_site_id': 9, 'target_warehouse_id': 7},
{'source_site_id': 9, 'target_warehouse_id': 7},
{
'source_site_id': 9,
'target_warehouse_id': 7,
'scope': TestBatchScope.formal(),
},
{
'source_site_id': 9,
'target_warehouse_id': 7,
'scope': TestBatchScope.formal(),
},
],
[call.kwargs for call in key_read.await_args_list],
)
@@ -1062,10 +1101,10 @@ class ReturnRequestTransactionRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'get_pallets_by_ids', new=pallet_locks),
self.assertRaises(PermissionException) as raised,
):
await ReturnService.request_return_services(self.db, self.page, self.user)
await ReturnService.request_return_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertEqual('无权访问该托盘', raised.exception.message)
inventory_locks.assert_awaited_once_with(self.db, [2, 5])
inventory_locks.assert_awaited_once_with(self.db, [2, 5], TestBatchScope.formal())
pallet_locks.assert_not_awaited()
self.assertEqual(2, scope_read.await_count)
self.assertEqual(1, key_read.await_count)
@@ -1112,12 +1151,12 @@ class ReturnRequestTransactionRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(MasterDao, 'get_site', new=AsyncMock(return_value=SimpleNamespace(status='0'))),
patch.object(InventoryDao, 'get_inventories_for_update', new=AsyncMock()) as inventory_locks,
):
result = await ReturnService.request_return_services(self.db, self.page, self.user)
result = await ReturnService.request_return_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertEqual(13, result.result)
self.assertTrue(probe.expired)
self.assertEqual(1, probe.return_id_reads)
order_lock.assert_awaited_once_with(self.db, 13, site_ids=[9], warehouse_ids=[])
order_lock.assert_awaited_once_with(self.db, 13, TestBatchScope.formal(), site_ids=[9], warehouse_ids=[])
inventory_locks.assert_not_awaited()
self.assertEqual(2, self.db.rollback.await_count)
@@ -1149,7 +1188,7 @@ class ReturnRequestTransactionRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'get_pallets_by_ids', new=pallet_locks),
):
try:
await ReturnService.request_return_services(db, self.page, self.user)
await ReturnService.request_return_services(db, self.page, self.user, TestBatchScope.formal())
except Exception as exc:
raised = exc
else:
@@ -1192,7 +1231,7 @@ class ReturnRequestTransactionRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(MasterDao, 'get_warehouse', new=AsyncMock(return_value=SimpleNamespace(status='0'))),
):
try:
await ReturnService.request_return_services(self.db, self.page, self.user)
await ReturnService.request_return_services(self.db, self.page, self.user, TestBatchScope.formal())
except Exception as exc:
raised = exc
else:
@@ -1285,7 +1324,7 @@ class ReturnRequestTransactionRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(return_service_module, 'datetime') as service_datetime,
):
service_datetime.now.return_value = self.fixed_time
result = await ReturnService.request_return_services(self.db, self.page, self.user)
result = await ReturnService.request_return_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertTrue(result.is_success)
self.assertEqual(13, result.result)
@@ -1293,12 +1332,20 @@ class ReturnRequestTransactionRedTest(unittest.IsolatedAsyncioTestCase):
self.assertEqual(2, key_read.await_count)
self.assertEqual(
[
{'source_site_id': 9, 'target_warehouse_id': 7},
{'source_site_id': 9, 'target_warehouse_id': 7},
{
'source_site_id': 9,
'target_warehouse_id': 7,
'scope': TestBatchScope.formal(),
},
{
'source_site_id': 9,
'target_warehouse_id': 7,
'scope': TestBatchScope.formal(),
},
],
[call.kwargs for call in key_read.await_args_list],
)
locks.assert_awaited_once_with(self.db, [2, 5])
locks.assert_awaited_once_with(self.db, [2, 5], TestBatchScope.formal())
site_access.assert_awaited_with(self.db, self.user, 9, for_update=True)
warehouse_access.assert_not_awaited()
self.assertEqual(ReturnStatus.REQUESTED.value, captured['order'].status)
@@ -1339,7 +1386,7 @@ class ReturnRequestTransactionRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'add_return_order', new=AsyncMock()) as add_order,
self.assertRaises(PermissionException) as raised,
):
await ReturnService.request_return_services(self.db, self.page, self.user)
await ReturnService.request_return_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertEqual('无权访问该托盘', raised.exception.message)
add_order.assert_not_awaited()
@@ -1370,7 +1417,7 @@ class ReturnRequestTransactionRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'get_pallets_by_ids', new=AsyncMock()) as pallet_locks,
self.assertRaises(ServiceException) as raised,
):
await ReturnService.request_return_services(db, self.page, admin)
await ReturnService.request_return_services(db, self.page, admin, TestBatchScope.formal())
self.assertEqual(expected_message, raised.exception.message)
pallet_locks.assert_not_awaited()
db.commit.assert_not_awaited()
@@ -1391,7 +1438,7 @@ class ReturnRequestTransactionRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(MasterDao, 'get_site', new=AsyncMock(return_value=SimpleNamespace(status='0'))),
patch.object(InventoryDao, 'get_inventories_for_update', new=AsyncMock()) as locks,
):
result = await ReturnService.request_return_services(self.db, self.page, self.user)
result = await ReturnService.request_return_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertEqual(13, result.result)
locks.assert_not_awaited()
self.db.commit.assert_not_awaited()
@@ -1408,7 +1455,7 @@ class ReturnRequestTransactionRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(AccessService, 'assert_site_access', new=AsyncMock()),
self.assertRaises(ServiceException) as raised,
):
await ReturnService.request_return_services(conflict_db, self.page, self.user)
await ReturnService.request_return_services(conflict_db, self.page, self.user, TestBatchScope.formal())
self.assertIn('幂等键已被其他请求使用', raised.exception.message)
conflict_db.commit.assert_not_awaited()
conflict_db.rollback.assert_awaited()
@@ -1435,7 +1482,7 @@ class ReturnRequestTransactionRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'get_pallets_by_ids', new=AsyncMock(return_value=[])),
):
try:
await ReturnService.request_return_services(self.db, self.page, self.user)
await ReturnService.request_return_services(self.db, self.page, self.user, TestBatchScope.formal())
except Exception as exc:
raised = exc
else:
@@ -1458,7 +1505,7 @@ class ReturnRequestTransactionRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'get_inventories_for_update', new=inventory_locks),
self.assertRaises(PermissionException) as raised,
):
await ReturnService.request_return_services(self.db, self.page, self.user)
await ReturnService.request_return_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertEqual('无权访问该托盘', raised.exception.message)
key_read.assert_not_awaited()
@@ -1483,6 +1530,7 @@ class ReturnRequestTransactionRedTest(unittest.IsolatedAsyncioTestCase):
self.page,
request_hash,
self.user,
TestBatchScope.formal(),
)
self.assertEqual(13, result.result)
@@ -1491,10 +1539,12 @@ class ReturnRequestTransactionRedTest(unittest.IsolatedAsyncioTestCase):
'request-key',
source_site_id=9,
target_warehouse_id=7,
scope=TestBatchScope.formal(),
)
order_lock.assert_awaited_once_with(
self.db,
13,
TestBatchScope.formal(),
site_ids=[9, 10],
warehouse_ids=[],
)
@@ -1511,7 +1561,7 @@ class ReturnRequestTransactionRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(AccessService, 'assert_site_access', new=AsyncMock()),
patch.object(MasterDao, 'get_site', new=AsyncMock(return_value=SimpleNamespace(status='0'))),
):
result = await ReturnService.request_return_services(self.db, self.page, admin)
result = await ReturnService.request_return_services(self.db, self.page, admin, TestBatchScope.formal())
self.assertEqual(13, result.result)
get_by_key.assert_awaited_once_with(
@@ -1519,6 +1569,7 @@ class ReturnRequestTransactionRedTest(unittest.IsolatedAsyncioTestCase):
'request-key',
source_site_id=9,
target_warehouse_id=7,
scope=TestBatchScope.formal(),
)
@@ -1583,12 +1634,14 @@ class ReturnConfirmTransactionRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(return_service_module, 'datetime') as service_datetime,
):
service_datetime.now.return_value = self.fixed_time
result = await ReturnService.confirm_return_services(self.db, 13, self.page, self.user)
result = await ReturnService.confirm_return_services(
self.db, 13, self.page, self.user, TestBatchScope.formal()
)
self.assertTrue(result.is_success)
self.assertEqual(13, result.result)
lock_order.assert_awaited_once_with(self.db, 13, site_ids=[], warehouse_ids=[7])
locks.assert_awaited_once_with(self.db, [2, 5])
lock_order.assert_awaited_once_with(self.db, 13, TestBatchScope.formal(), site_ids=[], warehouse_ids=[7])
locks.assert_awaited_once_with(self.db, [2, 5], TestBatchScope.formal())
warehouse_access.assert_awaited_with(self.db, self.user, 7, for_update=True)
self.assertEqual(PalletFlowState.FILLED_IN_WAREHOUSE.value, inventories[0].flow_state)
self.assertEqual(102, inventories[0].active_filling_id)
@@ -1633,7 +1686,7 @@ class ReturnConfirmTransactionRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'get_pallets_by_ids', new=AsyncMock(return_value=[])),
):
try:
await ReturnService.confirm_return_services(self.db, 13, self.page, self.user)
await ReturnService.confirm_return_services(self.db, 13, self.page, self.user, TestBatchScope.formal())
except ServiceException:
pass
@@ -1643,6 +1696,7 @@ class ReturnConfirmTransactionRedTest(unittest.IsolatedAsyncioTestCase):
'confirm-key',
source_site_id=9,
target_warehouse_id=7,
scope=TestBatchScope.formal(),
)
async def test_confirm_requires_exact_scan_set_before_inventory_locks(self) -> None:
@@ -1664,7 +1718,7 @@ class ReturnConfirmTransactionRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'get_inventories_for_update', new=AsyncMock()) as locks,
self.assertRaises(ServiceException) as raised,
):
await ReturnService.confirm_return_services(db, 13, page, self.user)
await ReturnService.confirm_return_services(db, 13, page, self.user, TestBatchScope.formal())
self.assertIn('扫码', raised.exception.message)
locks.assert_not_awaited()
db.rollback.assert_awaited()
@@ -1699,7 +1753,7 @@ class ReturnConfirmTransactionRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'update_return_order', new=AsyncMock()) as update_order,
self.assertRaises(ServiceException) as raised,
):
await ReturnService.confirm_return_services(db, 13, page, self.user)
await ReturnService.confirm_return_services(db, 13, page, self.user, TestBatchScope.formal())
self.assertTrue('快照' in raised.exception.message or '状态' in raised.exception.message)
update_order.assert_not_awaited()
db.commit.assert_not_awaited()
@@ -1725,7 +1779,9 @@ class ReturnConfirmTransactionRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(MasterDao, 'get_warehouse', new=AsyncMock(return_value=SimpleNamespace(status='0'))),
patch.object(InventoryDao, 'get_inventories_for_update', new=AsyncMock()) as locks,
):
result = await ReturnService.confirm_return_services(self.db, 13, self.page, self.user)
result = await ReturnService.confirm_return_services(
self.db, 13, self.page, self.user, TestBatchScope.formal()
)
self.assertEqual(13, result.result)
locks.assert_not_awaited()
self.db.commit.assert_not_awaited()
@@ -1744,7 +1800,9 @@ class ReturnConfirmTransactionRedTest(unittest.IsolatedAsyncioTestCase):
),
self.assertRaises(ServiceException) as raised,
):
await ReturnService.confirm_return_services(conflict_db, 13, conflict_page, self.user)
await ReturnService.confirm_return_services(
conflict_db, 13, conflict_page, self.user, TestBatchScope.formal()
)
self.assertIn('幂等键已被其他请求使用', raised.exception.message)
conflict_db.rollback.assert_awaited()
@@ -1769,12 +1827,13 @@ class ReturnConfirmTransactionRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(AccessService, 'assert_warehouse_access', new=AsyncMock()),
patch.object(MasterDao, 'get_warehouse', new=AsyncMock(return_value=SimpleNamespace(status='0'))),
):
result = await ReturnService.confirm_return_services(self.db, 13, self.page, admin)
result = await ReturnService.confirm_return_services(self.db, 13, self.page, admin, TestBatchScope.formal())
self.assertEqual(13, result.result)
get_order.assert_awaited_once_with(
self.db,
13,
TestBatchScope.formal(),
site_ids=None,
warehouse_ids=None,
)
@@ -1783,6 +1842,7 @@ class ReturnConfirmTransactionRedTest(unittest.IsolatedAsyncioTestCase):
'confirm-key',
source_site_id=9,
target_warehouse_id=7,
scope=TestBatchScope.formal(),
)
async def test_confirm_integrity_recovery_resolves_route_before_exact_key_lookup(self) -> None:
@@ -1819,18 +1879,20 @@ class ReturnConfirmTransactionRedTest(unittest.IsolatedAsyncioTestCase):
self.page,
confirm_hash,
self.user,
TestBatchScope.formal(),
)
self.assertEqual(13, result.result)
self.assertEqual(['return', 'key'], call_order)
route_read.assert_awaited_once_with(self.db, 13, site_ids=[], warehouse_ids=[7, 8])
route_read.assert_awaited_once_with(self.db, 13, TestBatchScope.formal(), site_ids=[], warehouse_ids=[7, 8])
key_read.assert_awaited_once_with(
self.db,
'confirm-key',
source_site_id=9,
target_warehouse_id=7,
scope=TestBatchScope.formal(),
)
order_lock.assert_awaited_once_with(self.db, 13, site_ids=[], warehouse_ids=[7, 8])
order_lock.assert_awaited_once_with(self.db, 13, TestBatchScope.formal(), site_ids=[], warehouse_ids=[7, 8])
self.db.rollback.assert_awaited_once()
async def test_confirm_rechecks_warehouse_mapping_before_business_locks(self) -> None:
@@ -1857,7 +1919,7 @@ class ReturnConfirmTransactionRedTest(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'get_pallets_by_ids', new=AsyncMock(return_value=[])),
):
try:
await ReturnService.confirm_return_services(self.db, 13, self.page, self.user)
await ReturnService.confirm_return_services(self.db, 13, self.page, self.user, TestBatchScope.formal())
except Exception as exc:
raised = exc
else:
shierfeng-fastapi-backend/tests/module_business/test_shipment_service.py
+156 -237
View File
@@ -23,7 +23,7 @@ from common.vo import (
PageResponseModel,
ResponseBaseModel,
)
from exceptions.exception import PermissionException, ServiceException
from exceptions.exception import PermissionException, ServiceException, ServiceWarning
from module_admin.entity.vo.user_vo import CurrentUserModel, UserInfoModel
from module_admin.service.login_service import LoginService
from module_business.controller import shipment_controller as shipment_controller_module
@@ -33,6 +33,7 @@ from module_business.dao.master_dao import MasterDao
from module_business.dao.operation_dao import OperationDao
from module_business.domain.enums import PalletEventType, PalletFlowState
from module_business.domain.pallet_state_machine import PalletStateMachine
from module_business.domain.test_batch_scope import TestBatchScope
from module_business.entity.do.master_do import BizCustomerSite, BizPallet, BizWarehouse
from module_business.entity.do.operation_do import (
BizFillingRecord,
@@ -152,6 +153,21 @@ def make_shipment(
class ShipmentServiceBootstrapTest(unittest.TestCase):
def test_public_business_methods_require_explicit_test_scope(self) -> None:
for method_name in (
'get_shipment_list_services',
'shipment_detail_services',
'get_warehouse_options_services',
'get_site_options_services',
'scan_shipment_pallet_services',
'add_shipment_services',
'edit_shipment_services',
'delete_shipment_services',
'confirm_shipment_services',
):
with self.subTest(method=method_name):
self.assertIn('test_scope', inspect.signature(getattr(ShipmentService, method_name)).parameters)
def test_shipment_service_module_exists(self) -> None:
spec = importlib.util.find_spec('module_business.service.shipment_service')
@@ -164,7 +180,7 @@ class ShipmentServiceBootstrapTest(unittest.TestCase):
)
signature = inspect.signature(ShipmentService.confirm_shipment_services)
self.assertEqual(
('query_db', 'shipment_id', 'page_object', 'current_user'),
('query_db', 'shipment_id', 'page_object', 'current_user', 'test_scope'),
tuple(signature.parameters),
)
hints = get_type_hints(ShipmentService.confirm_shipment_services)
@@ -215,25 +231,29 @@ class ShipmentInfrastructureContractTest(unittest.TestCase):
OperationDao.get_shipment_list: (
'db',
'query_object',
'is_page',
'warehouse_ids',
'site_ids',
'scope',
'is_page',
),
OperationDao.get_shipment_by_id: (
'db',
'shipment_id',
'scope',
'warehouse_ids',
'site_ids',
),
OperationDao.get_shipment_for_update: (
'db',
'shipment_id',
'scope',
'warehouse_ids',
'site_ids',
),
OperationDao.get_shipment_by_confirm_idempotency_key: (
'db',
'idempotency_key',
'scope',
'warehouse_ids',
'site_ids',
),
@@ -271,6 +291,7 @@ class ShipmentDetailDaoTest(unittest.IsolatedAsyncioTestCase):
12,
warehouse_ids=[7],
site_ids=[9],
scope=TestBatchScope.formal(),
)
self.assertIs(shipment, actual)
@@ -322,6 +343,7 @@ class ShipmentDetailDaoTest(unittest.IsolatedAsyncioTestCase):
12,
warehouse_ids=[7],
site_ids=[9],
scope=TestBatchScope.formal(),
)
self.assertIs(shipment, actual)
@@ -472,6 +494,7 @@ class ShipmentReadServiceTest(unittest.IsolatedAsyncioTestCase):
self.db,
query,
self.user,
TestBatchScope.formal(),
is_page=True,
)
except NotImplementedError:
@@ -500,9 +523,10 @@ class ShipmentReadServiceTest(unittest.IsolatedAsyncioTestCase):
self.db,
ShipmentPageQueryModel(),
self.user,
TestBatchScope.formal(),
)
try:
detail = await ShipmentService.shipment_detail_services(self.db, 12, self.user)
detail = await ShipmentService.shipment_detail_services(self.db, 12, self.user, TestBatchScope.formal())
except NotImplementedError:
self.fail('双范围单据详情尚未实现')
@@ -511,13 +535,15 @@ class ShipmentReadServiceTest(unittest.IsolatedAsyncioTestCase):
get_list.assert_awaited_once_with(
self.db,
unittest.mock.ANY,
True,
warehouse_ids=[7],
site_ids=[9],
scope=TestBatchScope.formal(),
is_page=True,
)
get_detail.assert_awaited_once_with(
self.db,
12,
TestBatchScope.formal(),
warehouse_ids=[7],
site_ids=[9],
)
@@ -540,8 +566,12 @@ class ShipmentReadServiceTest(unittest.IsolatedAsyncioTestCase):
patch.object(MasterDao, 'list_site', new=AsyncMock(return_value=sites)),
):
try:
warehouse_options = await ShipmentService.get_warehouse_options_services(self.db, self.user)
site_options = await ShipmentService.get_site_options_services(self.db, self.user)
warehouse_options = await ShipmentService.get_warehouse_options_services(
self.db, self.user, TestBatchScope.formal()
)
site_options = await ShipmentService.get_site_options_services(
self.db, self.user, TestBatchScope.formal()
)
except NotImplementedError:
self.fail('发货仓库/现场选项尚未实现')
@@ -598,6 +628,7 @@ class ShipmentReadServiceTest(unittest.IsolatedAsyncioTestCase):
'qr-2',
query,
self.user,
TestBatchScope.formal(),
)
except NotImplementedError:
self.fail('整托发货扫码尚未实现')
@@ -606,7 +637,11 @@ class ShipmentReadServiceTest(unittest.IsolatedAsyncioTestCase):
self.assertEqual(PalletFlowState.FILLED_IN_WAREHOUSE, result.flow_state)
self.assertEqual(8, result.remaining_packages)
self.assertEqual(['shipment'], result.allowed_actions)
get_filling.assert_awaited_once_with(self.db, inventory.active_filling_id)
get_filling.assert_awaited_once_with(
self.db,
inventory.active_filling_id,
TestBatchScope.formal(),
)
lock_inventory.assert_not_awaited()
lock_pallets.assert_not_awaited()
lock_filling.assert_not_awaited()
@@ -627,7 +662,7 @@ class ShipmentReadServiceTest(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'get_shipment_list', new=get_list),
self.assertRaises(PermissionException) as raised,
):
await ShipmentService.get_shipment_list_services(self.db, query, self.user)
await ShipmentService.get_shipment_list_services(self.db, query, self.user, TestBatchScope.formal())
self.assertEqual(expected_message, raised.exception.message)
get_list.assert_not_awaited()
@@ -640,12 +675,13 @@ class ShipmentReadServiceTest(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'get_shipment_by_id', new=get_detail),
self.assertRaises(PermissionException) as user_raised,
):
await ShipmentService.shipment_detail_services(self.db, 404, self.user)
await ShipmentService.shipment_detail_services(self.db, 404, self.user, TestBatchScope.formal())
self.assertEqual('无权访问该发货单', user_raised.exception.message)
get_detail.assert_awaited_once_with(
self.db,
404,
TestBatchScope.formal(),
warehouse_ids=[7],
site_ids=[9],
)
@@ -655,11 +691,12 @@ class ShipmentReadServiceTest(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'get_shipment_by_id', new=get_detail),
self.assertRaises(ServiceException) as admin_raised,
):
await ShipmentService.shipment_detail_services(self.db, 404, make_user(1))
await ShipmentService.shipment_detail_services(self.db, 404, make_user(1), TestBatchScope.formal())
self.assertEqual('发货单不存在', admin_raised.exception.message)
get_detail.assert_awaited_once_with(
self.db,
404,
TestBatchScope.formal(),
warehouse_ids=None,
site_ids=None,
)
@@ -715,6 +752,7 @@ class ShipmentReadServiceTest(unittest.IsolatedAsyncioTestCase):
'hidden-token',
ShipmentScanQueryModel(sourceWarehouseId=7, targetSiteId=9),
self.user,
TestBatchScope.formal(),
)
self.assertEqual('无权访问该托盘', raised.exception.message)
@@ -747,6 +785,7 @@ class ShipmentDraftServiceTest(unittest.IsolatedAsyncioTestCase):
self.db,
[2],
7,
TestBatchScope.formal(),
)
self.assertEqual([inventory], inventories)
@@ -794,7 +833,11 @@ class ShipmentDraftServiceTest(unittest.IsolatedAsyncioTestCase):
actions.append('pallet-lock')
return pallets
async def lock_filling(_db: AsyncSession, filling_id: int) -> BizFillingRecord:
async def lock_filling(
_db: AsyncSession,
filling_id: int,
_scope: TestBatchScope,
) -> BizFillingRecord:
actions.append(f'filling-lock-{filling_id}')
return fillings[filling_id]
@@ -844,7 +887,7 @@ class ShipmentDraftServiceTest(unittest.IsolatedAsyncioTestCase):
service_datetime.now.return_value = self.fixed_time
service_secrets.token_hex.return_value = 'draft-token'
try:
result = await ShipmentService.add_shipment_services(self.db, page, self.user)
result = await ShipmentService.add_shipment_services(self.db, page, self.user, TestBatchScope.formal())
except NotImplementedError:
self.fail('发货草稿新增尚未实现')
@@ -854,8 +897,8 @@ class ShipmentDraftServiceTest(unittest.IsolatedAsyncioTestCase):
self.assertEqual([2, 5], [item.pallet_id for item in captured['items']])
self.assertTrue(all(item.active_filling_id is None for item in captured['items']))
self.assertTrue(all(item.package_qty is None for item in captured['items']))
inventory_lock.assert_awaited_once_with(self.db, [2, 5])
pallet_lock.assert_awaited_once_with(self.db, [2, 5])
inventory_lock.assert_awaited_once_with(self.db, [2, 5], TestBatchScope.formal())
pallet_lock.assert_awaited_once_with(self.db, [2, 5], TestBatchScope.formal())
self.assertEqual(
[
'warehouse-access',
@@ -928,11 +971,11 @@ class ShipmentDraftServiceTest(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'replace_shipment_items', new=replace_items),
self.assertRaises(PermissionException) as raised,
):
await ShipmentService.add_shipment_services(self.db, page, self.user)
await ShipmentService.add_shipment_services(self.db, page, self.user, TestBatchScope.formal())
self.assertEqual('无权访问该仓库', raised.exception.message)
self.assertEqual(2, warehouse_read.await_count)
warehouse_read.assert_awaited_with(self.db, 7, for_update=True)
warehouse_read.assert_awaited_with(self.db, 7, TestBatchScope.formal(), for_update=True)
self.assertEqual(2, warehouse_mapping.await_count)
warehouse_mapping.assert_awaited_with(self.db, self.user, 7, for_update=True)
add_order.assert_not_awaited()
@@ -980,10 +1023,10 @@ class ShipmentDraftServiceTest(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'replace_shipment_items', new=replace_items),
self.assertRaises(ServiceException) as raised,
):
await ShipmentService.add_shipment_services(self.db, page, self.user)
await ShipmentService.add_shipment_services(self.db, page, self.user, TestBatchScope.formal())
self.assertEqual('来源仓库已停用', raised.exception.message)
warehouse_read.assert_awaited_with(self.db, 7, for_update=True)
warehouse_read.assert_awaited_with(self.db, 7, TestBatchScope.formal(), for_update=True)
add_order.assert_not_awaited()
replace_items.assert_not_awaited()
self.db.commit.assert_not_awaited()
@@ -1062,7 +1105,7 @@ class ShipmentDraftServiceTest(unittest.IsolatedAsyncioTestCase):
):
service_datetime.now.return_value = self.fixed_time
try:
result = await ShipmentService.edit_shipment_services(self.db, page, self.user)
result = await ShipmentService.edit_shipment_services(self.db, page, self.user, TestBatchScope.formal())
except NotImplementedError:
self.fail('发货草稿编辑尚未实现')
@@ -1070,6 +1113,7 @@ class ShipmentDraftServiceTest(unittest.IsolatedAsyncioTestCase):
lock_order.assert_awaited_once_with(
self.db,
12,
TestBatchScope.formal(),
warehouse_ids=[7, 8],
site_ids=[9, 10],
)
@@ -1129,6 +1173,7 @@ class ShipmentDraftServiceTest(unittest.IsolatedAsyncioTestCase):
async def get_warehouse(
_db: AsyncSession,
warehouse_id: int,
_scope: TestBatchScope,
**_kwargs: Any,
) -> BizWarehouse:
return BizWarehouse(
@@ -1141,6 +1186,7 @@ class ShipmentDraftServiceTest(unittest.IsolatedAsyncioTestCase):
async def get_site(
_db: AsyncSession,
site_id: int,
_scope: TestBatchScope,
_scenario: str = scenario,
_new_site_id: int = new_site_id,
**kwargs: Any,
@@ -1179,13 +1225,13 @@ class ShipmentDraftServiceTest(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'replace_shipment_items', new=replace_items),
self.assertRaises(exception_type) as raised,
):
await ShipmentService.edit_shipment_services(db, page, self.user)
await ShipmentService.edit_shipment_services(db, page, self.user, TestBatchScope.formal())
self.assertEqual(expected_message, raised.exception.message)
if scenario == 'current-warehouse-revoked':
warehouse_mapping.assert_any_await(db, self.user, 7, for_update=True)
else:
site_read.assert_any_await(db, 10, for_update=True)
site_read.assert_any_await(db, 10, TestBatchScope.formal(), for_update=True)
if scenario == 'new-site-revoked':
site_mapping.assert_any_await(db, self.user, 10, for_update=True)
update.assert_not_awaited()
@@ -1263,6 +1309,7 @@ class ShipmentDraftServiceTest(unittest.IsolatedAsyncioTestCase):
async def get_warehouse(
_db: AsyncSession,
warehouse_id: int,
_scope: TestBatchScope,
_disabled_ids: set[int] = disabled_warehouse_ids,
_locks: list[str] = locks,
**kwargs: Any,
@@ -1279,6 +1326,7 @@ class ShipmentDraftServiceTest(unittest.IsolatedAsyncioTestCase):
async def get_site(
_db: AsyncSession,
site_id: int,
_scope: TestBatchScope,
_disabled_ids: set[int] = disabled_site_ids,
_locks: list[str] = locks,
**kwargs: Any,
@@ -1316,7 +1364,7 @@ class ShipmentDraftServiceTest(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'replace_shipment_items', new=replace_items),
self.assertRaises(PermissionException) as raised,
):
await ShipmentService.edit_shipment_services(db, page, self.user)
await ShipmentService.edit_shipment_services(db, page, self.user, TestBatchScope.formal())
self.assertEqual('无权访问该发货单', raised.exception.message)
self.assertEqual(expected_locks, locks)
@@ -1361,6 +1409,7 @@ class ShipmentDraftServiceTest(unittest.IsolatedAsyncioTestCase):
async def get_warehouse(
_db: AsyncSession,
warehouse_id: int,
_scope: TestBatchScope,
**kwargs: Any,
) -> BizWarehouse:
if kwargs.get('for_update'):
@@ -1375,6 +1424,7 @@ class ShipmentDraftServiceTest(unittest.IsolatedAsyncioTestCase):
async def get_site(
_db: AsyncSession,
site_id: int,
_scope: TestBatchScope,
**kwargs: Any,
) -> BizCustomerSite:
if kwargs.get('for_update'):
@@ -1415,7 +1465,7 @@ class ShipmentDraftServiceTest(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'update_shipment', new=AsyncMock(side_effect=update)),
patch.object(OperationDao, 'replace_shipment_items', new=AsyncMock(side_effect=replace)),
):
result = await ShipmentService.edit_shipment_services(db, page, self.user)
result = await ShipmentService.edit_shipment_services(db, page, self.user, TestBatchScope.formal())
self.assertTrue(result.is_success)
self.assertEqual(
@@ -1437,222 +1487,55 @@ class ShipmentDraftServiceTest(unittest.IsolatedAsyncioTestCase):
)
async def test_batch_delete_preflights_all_drafts_before_any_delete(self) -> None:
documents = {
11: make_shipment(11, status='DRAFT'),
12: make_shipment(12, status='CONFIRMED'),
}
async def lock_order(
_db: AsyncSession,
shipment_id: int,
**_kwargs: Any,
) -> BizShipmentOrder:
return documents[shipment_id]
lock = AsyncMock()
delete = AsyncMock()
with (
patch.object(AccessDao, 'list_user_warehouse_ids', new=AsyncMock(return_value=[7])),
patch.object(AccessDao, 'list_user_site_ids', new=AsyncMock(return_value=[9])),
patch.object(OperationDao, 'get_shipment_for_update', new=AsyncMock(side_effect=lock_order)) as lock,
patch.object(OperationDao, 'get_shipment_for_update', new=lock),
patch.object(OperationDao, 'delete_shipment', new=delete),
self.assertRaises(ServiceWarning) as raised,
):
try:
with self.assertRaises(ServiceException):
await ShipmentService.delete_shipment_services(self.db, [12, 11], self.user)
except NotImplementedError:
self.fail('发货草稿原子批量删除尚未实现')
await ShipmentService.delete_shipment_services(self.db, [12, 11], self.user, TestBatchScope.formal())
self.assertEqual([11, 12], [call.args[1] for call in lock.await_args_list])
self.assertEqual('不支持单条物理删除，请通过测试数据批次清理', raised.exception.message)
lock.assert_not_awaited()
delete.assert_not_awaited()
self.db.commit.assert_not_awaited()
self.db.rollback.assert_awaited_once()
async def test_batch_delete_rechecks_all_current_routes_before_first_delete(self) -> None:
documents = {
11: make_shipment(11, source_warehouse_id=8, target_site_id=10, status='DRAFT'),
12: make_shipment(12, source_warehouse_id=7, target_site_id=9, status='DRAFT'),
}
revoked_warehouse_id = documents[11].source_warehouse_id
parent_lock_order: list[int] = []
async def lock_order(
_db: AsyncSession,
shipment_id: int,
**_kwargs: Any,
) -> BizShipmentOrder:
parent_lock_order.append(shipment_id)
return documents[shipment_id]
async def get_warehouse(
_db: AsyncSession,
warehouse_id: int,
**_kwargs: Any,
) -> BizWarehouse:
return BizWarehouse(
warehouse_id=warehouse_id,
warehouse_code=f'W-{warehouse_id}',
warehouse_name=f'{warehouse_id}号仓',
status='0',
)
async def get_site(
_db: AsyncSession,
site_id: int,
**_kwargs: Any,
) -> BizCustomerSite:
return BizCustomerSite(
site_id=site_id,
customer_id=1,
site_code=f'S-{site_id}',
site_name=f'{site_id}号现场',
status='0',
)
async def warehouse_access(
_db: AsyncSession,
_user: CurrentUserModel,
warehouse_id: int,
**kwargs: Any,
) -> None:
if warehouse_id == revoked_warehouse_id and kwargs.get('for_update'):
raise PermissionException(data='', message='无权访问该仓库')
lock = AsyncMock()
delete = AsyncMock()
warehouse_mapping = AsyncMock(side_effect=warehouse_access)
site_lock = AsyncMock(side_effect=get_site)
site_mapping = AsyncMock()
with (
patch.object(AccessDao, 'list_user_warehouse_ids', new=AsyncMock(return_value=[7, 8])),
patch.object(AccessDao, 'list_user_site_ids', new=AsyncMock(return_value=[9, 10])),
patch.object(OperationDao, 'get_shipment_for_update', new=AsyncMock(side_effect=lock_order)),
patch.object(MasterDao, 'get_warehouse', new=AsyncMock(side_effect=get_warehouse)),
patch.object(AccessService, 'assert_warehouse_access', new=warehouse_mapping),
patch.object(MasterDao, 'get_site', new=site_lock),
patch.object(AccessService, 'assert_site_access', new=site_mapping),
patch.object(OperationDao, 'get_shipment_for_update', new=lock),
patch.object(OperationDao, 'delete_shipment', new=delete),
self.assertRaises(PermissionException) as raised,
self.assertRaises(ServiceWarning) as raised,
):
await ShipmentService.delete_shipment_services(self.db, [12, 11], self.user)
await ShipmentService.delete_shipment_services(self.db, [12, 11], self.user, TestBatchScope.formal())
self.assertEqual('无权访问该发货单', raised.exception.message)
self.assertEqual([11, 12], parent_lock_order)
self.assertEqual([7, 8], [call.args[2] for call in warehouse_mapping.await_args_list])
self.assertTrue(all(call.kwargs.get('for_update') for call in warehouse_mapping.await_args_list))
self.assertEqual([9, 10], [call.args[1] for call in site_lock.await_args_list])
self.assertEqual([9, 10], [call.args[2] for call in site_mapping.await_args_list])
self.assertTrue(all(call.kwargs.get('for_update') for call in site_mapping.await_args_list))
self.assertEqual('不支持单条物理删除，请通过测试数据批次清理', raised.exception.message)
lock.assert_not_awaited()
delete.assert_not_awaited()
self.db.commit.assert_not_awaited()
self.db.rollback.assert_awaited_once()
async def test_batch_delete_locks_deduplicated_routes_stably_without_requiring_active(self) -> None:
db = MagicMock(spec=AsyncSession)
documents = {
11: make_shipment(11, source_warehouse_id=8, target_site_id=10, status='DRAFT'),
12: make_shipment(12, source_warehouse_id=7, target_site_id=10, status='DRAFT'),
13: make_shipment(13, source_warehouse_id=8, target_site_id=9, status='DRAFT'),
}
actions: list[str] = []
async def lock_order(
_db: AsyncSession,
shipment_id: int,
**_kwargs: Any,
) -> BizShipmentOrder:
actions.append(f'parent-{shipment_id}')
return documents[shipment_id]
async def get_warehouse(
_db: AsyncSession,
warehouse_id: int,
**kwargs: Any,
) -> BizWarehouse:
self.assertTrue(kwargs.get('for_update'))
actions.append(f'warehouse-master-{warehouse_id}')
return BizWarehouse(
warehouse_id=warehouse_id,
warehouse_code=f'W-{warehouse_id}',
warehouse_name=f'{warehouse_id}号仓',
status='1',
)
async def warehouse_access(
_db: AsyncSession,
_user: CurrentUserModel,
warehouse_id: int,
**kwargs: Any,
) -> None:
self.assertTrue(kwargs.get('for_update'))
actions.append(f'warehouse-mapping-{warehouse_id}')
async def get_site(
_db: AsyncSession,
site_id: int,
**kwargs: Any,
) -> BizCustomerSite:
self.assertTrue(kwargs.get('for_update'))
actions.append(f'site-master-{site_id}')
return BizCustomerSite(
site_id=site_id,
customer_id=1,
site_code=f'S-{site_id}',
site_name=f'{site_id}号现场',
status='1',
)
async def site_access(
_db: AsyncSession,
_user: CurrentUserModel,
site_id: int,
**kwargs: Any,
) -> None:
self.assertTrue(kwargs.get('for_update'))
actions.append(f'site-mapping-{site_id}')
async def delete(_db: AsyncSession, shipment_id: int) -> None:
actions.append(f'delete-{shipment_id}')
async def commit() -> None:
actions.append('commit')
db.commit.side_effect = commit
lock = AsyncMock()
delete = AsyncMock()
with (
patch.object(AccessDao, 'list_user_warehouse_ids', new=AsyncMock(return_value=[7, 8])),
patch.object(AccessDao, 'list_user_site_ids', new=AsyncMock(return_value=[9, 10])),
patch.object(OperationDao, 'get_shipment_for_update', new=AsyncMock(side_effect=lock_order)),
patch.object(MasterDao, 'get_warehouse', new=AsyncMock(side_effect=get_warehouse)),
patch.object(
AccessService,
'assert_warehouse_access',
new=AsyncMock(side_effect=warehouse_access),
),
patch.object(MasterDao, 'get_site', new=AsyncMock(side_effect=get_site)),
patch.object(AccessService, 'assert_site_access', new=AsyncMock(side_effect=site_access)),
patch.object(OperationDao, 'delete_shipment', new=AsyncMock(side_effect=delete)),
patch.object(OperationDao, 'get_shipment_for_update', new=lock),
patch.object(OperationDao, 'delete_shipment', new=delete),
self.assertRaises(ServiceWarning) as raised,
):
result = await ShipmentService.delete_shipment_services(db, [13, 11, 12], self.user)
await ShipmentService.delete_shipment_services(
db,
[13, 11, 12],
self.user,
TestBatchScope.formal(),
)
self.assertTrue(result.is_success)
self.assertEqual(
[
'parent-11',
'parent-12',
'parent-13',
'warehouse-master-7',
'warehouse-mapping-7',
'warehouse-master-8',
'warehouse-mapping-8',
'site-master-9',
'site-mapping-9',
'site-master-10',
'site-mapping-10',
'delete-11',
'delete-12',
'delete-13',
'commit',
],
actions,
)
self.assertEqual('不支持单条物理删除，请通过测试数据批次清理', raised.exception.message)
lock.assert_not_awaited()
delete.assert_not_awaited()
db.commit.assert_not_awaited()
class ShipmentConfirmServiceTest(unittest.IsolatedAsyncioTestCase):
@@ -1695,7 +1578,11 @@ class ShipmentConfirmServiceTest(unittest.IsolatedAsyncioTestCase):
actions.append('pallet-lock')
return pallets
async def filling_lock(_db: AsyncSession, filling_id: int) -> BizFillingRecord:
async def filling_lock(
_db: AsyncSession,
filling_id: int,
_scope: TestBatchScope,
) -> BizFillingRecord:
actions.append(f'filling-lock-{filling_id}')
return fillings[filling_id]
@@ -1791,6 +1678,7 @@ class ShipmentConfirmServiceTest(unittest.IsolatedAsyncioTestCase):
12,
self.command,
self.user,
TestBatchScope.formal(),
)
except NotImplementedError:
self.fail('多托盘整托确认尚未实现')
@@ -1821,6 +1709,7 @@ class ShipmentConfirmServiceTest(unittest.IsolatedAsyncioTestCase):
detail_read.assert_awaited_once_with(
self.db,
12,
TestBatchScope.formal(),
warehouse_ids=[7],
site_ids=[9],
)
@@ -1923,12 +1812,13 @@ class ShipmentConfirmServiceTest(unittest.IsolatedAsyncioTestCase):
12,
self.command,
self.user,
TestBatchScope.formal(),
)
self.assertTrue(result.is_success)
warehouse_lock.assert_awaited_once_with(self.db, 7, for_update=True)
warehouse_lock.assert_awaited_once_with(self.db, 7, TestBatchScope.formal(), for_update=True)
warehouse_access.assert_awaited_once_with(self.db, self.user, 7, for_update=True)
site_lock.assert_awaited_once_with(self.db, 9, for_update=True)
site_lock.assert_awaited_once_with(self.db, 9, TestBatchScope.formal(), for_update=True)
site_access.assert_awaited_once_with(self.db, self.user, 9, for_update=True)
inventory_lock.assert_not_awaited()
update.assert_not_awaited()
@@ -2009,12 +1899,13 @@ class ShipmentConfirmServiceTest(unittest.IsolatedAsyncioTestCase):
12,
self.command,
self.user,
TestBatchScope.formal(),
)
self.assertTrue(result.is_success)
warehouse_lock.assert_awaited_once_with(db, 7, for_update=True)
warehouse_lock.assert_awaited_once_with(db, 7, TestBatchScope.formal(), for_update=True)
warehouse_access.assert_awaited_once_with(db, self.user, 7, for_update=True)
site_lock.assert_awaited_once_with(db, 9, for_update=True)
site_lock.assert_awaited_once_with(db, 9, TestBatchScope.formal(), for_update=True)
site_access.assert_awaited_once_with(db, self.user, 9, for_update=True)
self.assertEqual(
original_snapshots,
@@ -2081,12 +1972,13 @@ class ShipmentConfirmServiceTest(unittest.IsolatedAsyncioTestCase):
12,
self.command,
self.user,
TestBatchScope.formal(),
)
self.assertEqual('无权访问该发货单', raised.exception.message)
warehouse_lock.assert_awaited_once_with(self.db, 7, for_update=True)
warehouse_lock.assert_awaited_once_with(self.db, 7, TestBatchScope.formal(), for_update=True)
warehouse_mapping.assert_awaited_once_with(self.db, self.user, 7, for_update=True)
site_lock.assert_awaited_once_with(self.db, 9, for_update=True)
site_lock.assert_awaited_once_with(self.db, 9, TestBatchScope.formal(), for_update=True)
site_mapping.assert_awaited_once_with(self.db, self.user, 9, for_update=True)
inventory_lock.assert_not_awaited()
update.assert_not_awaited()
@@ -2146,10 +2038,11 @@ class ShipmentConfirmServiceTest(unittest.IsolatedAsyncioTestCase):
12,
self.command,
self.user,
TestBatchScope.formal(),
)
self.assertTrue(result.is_success)
lock_validate.assert_awaited_once_with(self.db, [2], 7)
lock_validate.assert_awaited_once_with(self.db, [2], 7, TestBatchScope.formal())
self.assertEqual((102, 6), (locked.items[0].active_filling_id, locked.items[0].package_qty))
self.assertIsNone(initial.items[0].active_filling_id)
self.assertIsNone(initial.items[0].package_qty)
@@ -2175,7 +2068,9 @@ class ShipmentConfirmServiceTest(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'get_shipment_for_update', new=parent_lock),
self.assertRaises(ServiceException) as raised,
):
await ShipmentService.confirm_shipment_services(self.db, 12, self.command, self.user)
await ShipmentService.confirm_shipment_services(
self.db, 12, self.command, self.user, TestBatchScope.formal()
)
self.assertEqual('确认发货失败，幂等键已被其他请求使用', raised.exception.message)
parent_lock.assert_not_awaited()
@@ -2199,6 +2094,7 @@ class ShipmentConfirmServiceTest(unittest.IsolatedAsyncioTestCase):
async def read_key(
_db: AsyncSession,
_key: str,
_scope: TestBatchScope,
*,
warehouse_ids: list[int] | None = None,
site_ids: list[int] | None = None,
@@ -2254,18 +2150,21 @@ class ShipmentConfirmServiceTest(unittest.IsolatedAsyncioTestCase):
12,
self.command,
self.user,
TestBatchScope.formal(),
)
self.assertTrue(result.is_success)
get_detail.assert_awaited_once_with(
self.db,
12,
TestBatchScope.formal(),
warehouse_ids=[7, 8],
site_ids=[9, 10],
)
key_read.assert_awaited_once_with(
self.db,
'confirm-key',
TestBatchScope.formal(),
warehouse_ids=[7],
site_ids=[9],
)
@@ -2295,7 +2194,9 @@ class ShipmentConfirmServiceTest(unittest.IsolatedAsyncioTestCase):
),
self.assertRaises(ServiceException) as raised,
):
await ShipmentService.confirm_shipment_services(self.db, 12, self.command, self.user)
await ShipmentService.confirm_shipment_services(
self.db, 12, self.command, self.user, TestBatchScope.formal()
)
self.assertEqual('确认发货失败，幂等键已被其他请求使用', raised.exception.message)
self.assertEqual(2, self.db.rollback.await_count)
@@ -2359,19 +2260,22 @@ class ShipmentConfirmServiceTest(unittest.IsolatedAsyncioTestCase):
patch.object(AccessService, 'assert_site_access', new=AsyncMock()),
self.assertRaises(PermissionException) as raised,
):
await ShipmentService.confirm_shipment_services(self.db, 12, self.command, self.user)
await ShipmentService.confirm_shipment_services(
self.db, 12, self.command, self.user, TestBatchScope.formal()
)
self.assertEqual('无权访问该发货单', raised.exception.message)
self.assertEqual(2, parent_lock.await_count)
parent_lock.assert_awaited_with(
self.db,
12,
TestBatchScope.formal(),
warehouse_ids=[7],
site_ids=[9],
)
warehouse_lock.assert_awaited_once_with(self.db, 7, for_update=True)
warehouse_lock.assert_awaited_once_with(self.db, 7, TestBatchScope.formal(), for_update=True)
warehouse_mapping.assert_awaited_once_with(self.db, self.user, 7, for_update=True)
site_lock.assert_awaited_once_with(self.db, 9, for_update=True)
site_lock.assert_awaited_once_with(self.db, 9, TestBatchScope.formal(), for_update=True)
self.db.commit.assert_not_awaited()
self.assertEqual(2, self.db.rollback.await_count)
@@ -2425,14 +2329,16 @@ class ShipmentConfirmServiceTest(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'add_event', new=add_event),
self.assertRaises(ServiceException) as raised,
):
await ShipmentService.confirm_shipment_services(self.db, 12, self.command, self.user)
await ShipmentService.confirm_shipment_services(
self.db, 12, self.command, self.user, TestBatchScope.formal()
)
self.assertEqual('来源仓库已停用', raised.exception.message)
self.assertEqual('DRAFT', shipment.status)
self.assertEqual('FILLED_IN_WAREHOUSE', inventory.flow_state)
self.assertEqual(4, inventory.version)
mapping.assert_awaited_once_with(self.db, self.user, 7, for_update=True)
site_lock.assert_awaited_once_with(self.db, 9, for_update=True)
site_lock.assert_awaited_once_with(self.db, 9, TestBatchScope.formal(), for_update=True)
site_mapping.assert_awaited_once_with(self.db, self.user, 9, for_update=True)
update.assert_not_awaited()
add_event.assert_not_awaited()
@@ -2491,6 +2397,7 @@ class ShipmentConfirmServiceTest(unittest.IsolatedAsyncioTestCase):
12,
self.command,
self.user,
TestBatchScope.formal(),
)
self.assertTrue(result.is_success)
@@ -2523,6 +2430,7 @@ class ShipmentConfirmServiceTest(unittest.IsolatedAsyncioTestCase):
async def read_key(
_db: AsyncSession,
_key: str,
_scope: TestBatchScope,
*,
warehouse_ids: list[int] | None = None,
site_ids: list[int] | None = None,
@@ -2584,6 +2492,7 @@ class ShipmentConfirmServiceTest(unittest.IsolatedAsyncioTestCase):
12,
self.command,
self.user,
TestBatchScope.formal(),
)
self.assertTrue(result.is_success)
@@ -2595,12 +2504,14 @@ class ShipmentConfirmServiceTest(unittest.IsolatedAsyncioTestCase):
unittest.mock.call(
self.db,
'confirm-key',
TestBatchScope.formal(),
warehouse_ids=[7],
site_ids=[9],
),
unittest.mock.call(
self.db,
'confirm-key',
TestBatchScope.formal(),
warehouse_ids=[7],
site_ids=[9],
),
@@ -2667,7 +2578,9 @@ class ShipmentConfirmServiceTest(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'add_event', new=add_event),
self.assertRaises(PermissionException) as raised,
):
await ShipmentService.confirm_shipment_services(self.db, 12, self.command, self.user)
await ShipmentService.confirm_shipment_services(
self.db, 12, self.command, self.user, TestBatchScope.formal()
)
self.assertEqual('无权访问该发货单', raised.exception.message)
self.assertEqual('DRAFT', shipment.status)
@@ -2675,7 +2588,7 @@ class ShipmentConfirmServiceTest(unittest.IsolatedAsyncioTestCase):
self.assertEqual(7, inventory.warehouse_id)
self.assertIsNone(inventory.site_id)
self.assertEqual(4, inventory.version)
site_lock.assert_awaited_once_with(self.db, 9, for_update=True)
site_lock.assert_awaited_once_with(self.db, 9, TestBatchScope.formal(), for_update=True)
site_mapping.assert_awaited_once_with(self.db, self.user, 9, for_update=True)
transition.assert_not_called()
update.assert_not_awaited()
@@ -2690,7 +2603,11 @@ class ShipmentConfirmServiceTest(unittest.IsolatedAsyncioTestCase):
update = AsyncMock()
add_event = AsyncMock()
async def get_filling(_db: AsyncSession, filling_id: int) -> BizFillingRecord:
async def get_filling(
_db: AsyncSession,
filling_id: int,
_scope: TestBatchScope,
) -> BizFillingRecord:
return fillings[filling_id]
transition = MagicMock(side_effect=[None, ValueError('second pallet invalid')])
@@ -2747,7 +2664,9 @@ class ShipmentConfirmServiceTest(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'add_event', new=add_event),
self.assertRaisesRegex(ValueError, 'second pallet invalid'),
):
await ShipmentService.confirm_shipment_services(self.db, 12, self.command, self.user)
await ShipmentService.confirm_shipment_services(
self.db, 12, self.command, self.user, TestBatchScope.formal()
)
self.assertEqual('DRAFT', shipment.status)
self.assertTrue(all(item.active_filling_id is None and item.package_qty is None for item in shipment.items))
shierfeng-fastapi-backend/tests/module_business/test_usage_service.py
+116 -52
View File
@@ -31,6 +31,7 @@ from module_business.dao.inventory_dao import InventoryDao
from module_business.dao.master_dao import MasterDao
from module_business.dao.operation_dao import OperationDao
from module_business.domain.enums import PalletEventType, PalletFlowState
from module_business.domain.test_batch_scope import TestBatchScope
from module_business.entity.do.master_do import BizCustomerSite, BizPallet, BizProductionLine
from module_business.entity.do.operation_do import (
BizFillingRecord,
@@ -48,6 +49,7 @@ from module_business.entity.vo.operation_vo import (
UsageSuccessResponseModel,
)
from module_business.service.access_service import AccessService
from tests.module_business.test_batch_fixtures import make_test_scope
SERVICE_SPEC = importlib.util.find_spec('module_business.service.usage_service')
CONTROLLER_SPEC = importlib.util.find_spec('module_business.controller.usage_controller')
@@ -223,6 +225,17 @@ class TestUsageBootstrap(unittest.TestCase):
@unittest.skipUnless(UsageService is not None, 'UsageService 尚未实现')
class TestUsagePublicContract(unittest.TestCase):
def test_public_business_methods_require_explicit_test_scope(self) -> None:
for method_name in (
'get_usage_list_services',
'usage_detail_services',
'get_line_options_services',
'scan_usage_pallet_services',
'record_usage_services',
):
with self.subTest(method=method_name):
self.assertIn('test_scope', inspect.signature(getattr(UsageService, method_name)).parameters)
def test_service_exposes_complete_usage_workflow(self) -> None:
expected = {
'get_usage_list_services',
@@ -235,11 +248,12 @@ class TestUsagePublicContract(unittest.TestCase):
def test_record_signature_and_types_are_exact(self) -> None:
signature = inspect.signature(UsageService.record_usage_services)
self.assertEqual(('query_db', 'page_object', 'current_user'), tuple(signature.parameters))
self.assertEqual(('query_db', 'page_object', 'current_user', 'test_scope'), tuple(signature.parameters))
hints = get_type_hints(UsageService.record_usage_services)
self.assertIs(AsyncSession, hints['query_db'])
self.assertIs(UsageCreateModel, hints['page_object'])
self.assertIs(CurrentUserModel, hints['current_user'])
self.assertIs(TestBatchScope, hints['test_scope'])
self.assertIs(CrudResponseModel, hints['return'])
def test_request_hash_is_stable_normalized_and_excludes_idempotency_key(self) -> None:
@@ -319,9 +333,15 @@ class TestUsageReadServices(unittest.IsolatedAsyncioTestCase):
patch.object(AccessDao, 'list_user_site_ids', new=AsyncMock(return_value=[11, 9, 9])),
patch.object(OperationDao, 'get_usage_list', new=get_list),
):
result = await UsageService.get_usage_list_services(self.db, query, self.user)
result = await UsageService.get_usage_list_services(self.db, query, self.user, TestBatchScope.formal())
get_list.assert_awaited_once_with(self.db, query, True, site_ids=[9, 11])
get_list.assert_awaited_once_with(
self.db,
query,
site_ids=[9, 11],
scope=TestBatchScope.formal(),
is_page=True,
)
self.assertEqual(1, result.total)
self.assertIsInstance(result.rows[0], UsageModel)
@@ -337,6 +357,7 @@ class TestUsageReadServices(unittest.IsolatedAsyncioTestCase):
self.db,
UsagePageQueryModel(pageNum=2, pageSize=7),
self.user,
TestBatchScope.formal(),
is_page=is_page,
)
@@ -360,6 +381,7 @@ class TestUsageReadServices(unittest.IsolatedAsyncioTestCase):
self.db,
UsagePageQueryModel(siteId=10),
self.user,
TestBatchScope.formal(),
)
self.assertEqual('无权访问该客户现场', raised.exception.message)
@@ -377,11 +399,18 @@ class TestUsageReadServices(unittest.IsolatedAsyncioTestCase):
self.db,
query,
make_user(1),
TestBatchScope.formal(),
is_page=False,
)
get_scope.assert_not_awaited()
get_list.assert_awaited_once_with(self.db, query, False, site_ids=None)
get_list.assert_awaited_once_with(
self.db,
query,
site_ids=None,
scope=TestBatchScope.formal(),
is_page=False,
)
self.assertEqual([], result)
async def test_detail_is_scoped_and_hides_missing_but_admin_gets_precise_error(self) -> None:
@@ -396,9 +425,14 @@ class TestUsageReadServices(unittest.IsolatedAsyncioTestCase):
patch.object(OperationDao, 'get_usage_by_id', new=get_detail),
self.assertRaises(expected_exception) as raised,
):
await UsageService.usage_detail_services(self.db, 61, user)
await UsageService.usage_detail_services(self.db, 61, user, TestBatchScope.formal())
get_detail.assert_awaited_once_with(self.db, 61, site_ids=expected_scope)
get_detail.assert_awaited_once_with(
self.db,
61,
TestBatchScope.formal(),
site_ids=expected_scope,
)
self.assertEqual(expected_message, raised.exception.message)
async def test_line_options_require_site_access_and_only_return_enabled_lines_for_site(self) -> None:
@@ -415,14 +449,15 @@ class TestUsageReadServices(unittest.IsolatedAsyncioTestCase):
patch.object(MasterDao, 'get_site', new=AsyncMock(return_value=make_site())),
patch.object(MasterDao, 'list_line', new=list_line),
):
result = await UsageService.get_line_options_services(self.db, 9, self.user)
result = await UsageService.get_line_options_services(self.db, 9, self.user, TestBatchScope.formal())
access.assert_awaited_once_with(self.db, self.user, 9)
query = list_line.await_args.args[1]
self.assertIsInstance(query, LinePageQueryModel)
self.assertEqual(9, query.site_id)
self.assertEqual('0', query.status)
self.assertFalse(list_line.await_args.args[2])
self.assertEqual(TestBatchScope.formal(), list_line.await_args.args[2])
self.assertFalse(list_line.await_args.args[3])
self.assertEqual([3, 6], [option.id for option in result])
self.assertTrue(all(isinstance(option, BusinessOptionModel) for option in result))
@@ -439,7 +474,7 @@ class TestUsageReadServices(unittest.IsolatedAsyncioTestCase):
patch.object(MasterDao, 'list_line', new=list_line),
self.assertRaises(PermissionException),
):
await UsageService.get_line_options_services(self.db, 9, self.user)
await UsageService.get_line_options_services(self.db, 9, self.user, TestBatchScope.formal())
get_site.assert_not_awaited()
list_line.assert_not_awaited()
@@ -466,10 +501,10 @@ class TestUsageReadServices(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'get_pallets_by_ids', new=pallet_lock),
patch.object(OperationDao, 'get_active_filling_for_update', new=filling_lock),
):
result = await UsageService.scan_usage_pallet_services(self.db, 'qr-2', self.user)
result = await UsageService.scan_usage_pallet_services(self.db, 'qr-2', self.user, TestBatchScope.formal())
access.assert_awaited_once_with(self.db, self.user, 9)
get_filling.assert_awaited_once_with(self.db, 31)
get_filling.assert_awaited_once_with(self.db, 31, TestBatchScope.formal())
inventory_lock.assert_not_awaited()
pallet_lock.assert_not_awaited()
filling_lock.assert_not_awaited()
@@ -489,7 +524,7 @@ class TestUsageReadServices(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'get_pallet_by_qr_token', new=AsyncMock(return_value=None)),
self.assertRaises(PermissionException) as missing,
):
await UsageService.scan_usage_pallet_services(self.db, 'missing', self.user)
await UsageService.scan_usage_pallet_services(self.db, 'missing', self.user, TestBatchScope.formal())
self.assertEqual('无权访问该托盘', missing.exception.message)
with (
@@ -497,7 +532,7 @@ class TestUsageReadServices(unittest.IsolatedAsyncioTestCase):
patch.object(MasterDao, 'get_pallet_inventory', new=AsyncMock(return_value=make_inventory(site_id=None))),
self.assertRaises(PermissionException) as non_site,
):
await UsageService.scan_usage_pallet_services(self.db, 'qr-2', self.user)
await UsageService.scan_usage_pallet_services(self.db, 'qr-2', self.user, TestBatchScope.formal())
self.assertEqual('无权访问该托盘', non_site.exception.message)
with (
@@ -510,7 +545,7 @@ class TestUsageReadServices(unittest.IsolatedAsyncioTestCase):
),
self.assertRaises(PermissionException) as unauthorized,
):
await UsageService.scan_usage_pallet_services(self.db, 'qr-2', self.user)
await UsageService.scan_usage_pallet_services(self.db, 'qr-2', self.user, TestBatchScope.formal())
self.assertEqual('无权访问该托盘', unauthorized.exception.message)
async def test_scan_admin_keeps_precise_missing_error(self) -> None:
@@ -518,7 +553,7 @@ class TestUsageReadServices(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'get_pallet_by_qr_token', new=AsyncMock(return_value=None)),
self.assertRaises(ServiceException) as raised,
):
await UsageService.scan_usage_pallet_services(self.db, 'missing', make_user(1))
await UsageService.scan_usage_pallet_services(self.db, 'missing', make_user(1), TestBatchScope.formal())
self.assertEqual('托盘不存在', raised.exception.message)
@@ -644,6 +679,7 @@ class TestUsageControllerResponse(unittest.IsolatedAsyncioTestCase):
db = MagicMock(spec=AsyncSession)
user = make_user()
page = make_page()
test_scope = make_test_scope(9)
service = AsyncMock(
return_value=CrudResponseModel(
is_success=True,
@@ -661,9 +697,10 @@ class TestUsageControllerResponse(unittest.IsolatedAsyncioTestCase):
add_usage=page,
query_db=db,
current_user=user,
test_scope=test_scope,
)
service.assert_awaited_once_with(db, page, user)
service.assert_awaited_once_with(db, page, user, test_scope)
payload = json.loads(response.body)
self.assertEqual('使用成功', payload['msg'])
self.assertIn('data', payload)
@@ -738,12 +775,13 @@ class TestRecordUsageCore(unittest.IsolatedAsyncioTestCase):
async def read_line(
db: AsyncSession,
line_id: int,
scope: TestBatchScope,
*,
for_update: bool = False,
) -> BizProductionLine | None:
if for_update:
return await line_lock(db, line_id, for_update=True)
return await preflight_line_read(db, line_id)
return await line_lock(db, line_id, scope, for_update=True)
return await preflight_line_read(db, line_id, scope)
stack.enter_context(patch.object(AccessDao, 'list_user_site_ids', new=scope_read))
stack.enter_context(patch.object(AccessService, 'assert_site_access', new=site_access))
@@ -884,7 +922,7 @@ class TestRecordUsageCore(unittest.IsolatedAsyncioTestCase):
patch('module_business.service.usage_service.datetime') as mocked_datetime,
):
mocked_datetime.now.return_value = self.fixed_time
result = await UsageService.record_usage_services(self.db, self.page, self.user)
result = await UsageService.record_usage_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertEqual(
[
@@ -987,6 +1025,7 @@ class TestRecordUsageCore(unittest.IsolatedAsyncioTestCase):
self.db,
make_page(used_packages=3),
self.user,
TestBatchScope.formal(),
)
self.assertTrue(result.is_success)
@@ -1028,6 +1067,7 @@ class TestRecordUsageCore(unittest.IsolatedAsyncioTestCase):
self.db,
make_page(used_packages=2),
self.user,
TestBatchScope.formal(),
)
self.assertTrue(result.is_success)
self.assertEqual(4, same_inventory.current_line_id)
@@ -1040,7 +1080,7 @@ class TestRecordUsageCore(unittest.IsolatedAsyncioTestCase):
)
stack, mocks = self._patch_record_path(inventory=other_inventory)
with stack, self.assertRaises(ServiceException) as raised:
await UsageService.record_usage_services(self.db, self.page, self.user)
await UsageService.record_usage_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertIn('已绑定其他产线', raised.exception.message)
mocks['add_usage'].assert_not_awaited()
mocks['add_event'].assert_not_awaited()
@@ -1060,7 +1100,7 @@ class TestRecordUsageCore(unittest.IsolatedAsyncioTestCase):
mocks['preflight_line_read'].return_value = None
mocks['line_lock'].return_value = None
with stack, self.assertRaises(ServiceException) as raised:
await UsageService.record_usage_services(self.db, self.page, self.user)
await UsageService.record_usage_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertEqual(message, raised.exception.message)
mocks['add_usage'].assert_not_awaited()
mocks['add_event'].assert_not_awaited()
@@ -1091,7 +1131,7 @@ class TestRecordUsageCore(unittest.IsolatedAsyncioTestCase):
self.db.reset_mock()
stack, mocks = self._patch_record_path(inventory=inventory)
with stack, self.assertRaises(ServiceException) as raised:
await UsageService.record_usage_services(self.db, page, self.user)
await UsageService.record_usage_services(self.db, page, self.user, TestBatchScope.formal())
self.assertEqual(message, raised.exception.message)
mocks['add_usage'].assert_not_awaited()
mocks['add_event'].assert_not_awaited()
@@ -1102,7 +1142,7 @@ class TestRecordUsageCore(unittest.IsolatedAsyncioTestCase):
access = AsyncMock(side_effect=PermissionException(data='', message='无权访问该客户现场'))
stack, mocks = self._patch_record_path(access=access)
with stack, self.assertRaises(PermissionException) as raised:
await UsageService.record_usage_services(self.db, self.page, self.user)
await UsageService.record_usage_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertEqual('无权访问该托盘', raised.exception.message)
mocks['inventory_lock'].assert_awaited_once()
@@ -1127,10 +1167,15 @@ class TestRecordUsageCore(unittest.IsolatedAsyncioTestCase):
access = AsyncMock(side_effect=access_check)
stack, mocks = self._patch_record_path(site=make_site(status='1'), access=access)
with stack, self.assertRaises(PermissionException) as raised:
await UsageService.record_usage_services(self.db, self.page, self.user)
await UsageService.record_usage_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertEqual('无权访问该托盘', raised.exception.message)
mocks['site_lock'].assert_awaited_once_with(self.db, 9, for_update=True)
mocks['site_lock'].assert_awaited_once_with(
self.db,
9,
TestBatchScope.formal(),
for_update=True,
)
access.assert_awaited_with(self.db, self.user, 9, for_update=True)
mocks['line_lock'].assert_not_awaited()
mocks['add_usage'].assert_not_awaited()
@@ -1144,7 +1189,7 @@ class TestRecordUsageCore(unittest.IsolatedAsyncioTestCase):
if site is None:
mocks['site_lock'].return_value = None
with stack, self.assertRaises(ServiceException) as raised:
await UsageService.record_usage_services(self.db, self.page, make_user(1))
await UsageService.record_usage_services(self.db, self.page, make_user(1), TestBatchScope.formal())
self.assertEqual(message, raised.exception.message)
mocks['add_usage'].assert_not_awaited()
self.assertEqual(2, self.db.rollback.await_count)
@@ -1162,7 +1207,7 @@ class TestRecordUsageCore(unittest.IsolatedAsyncioTestCase):
self.db.reset_mock()
stack, mocks = self._patch_record_path(**overrides)
with stack, self.assertRaises(ServiceException):
await UsageService.record_usage_services(self.db, self.page, self.user)
await UsageService.record_usage_services(self.db, self.page, self.user, TestBatchScope.formal())
mocks['add_usage'].assert_not_awaited()
mocks['update_filling'].assert_not_awaited()
mocks['add_event'].assert_not_awaited()
@@ -1173,7 +1218,7 @@ class TestRecordUsageCore(unittest.IsolatedAsyncioTestCase):
inventory = make_inventory(version=-1)
stack, mocks = self._patch_record_path(inventory=inventory)
with stack, self.assertRaises(ServiceException) as raised:
await UsageService.record_usage_services(self.db, self.page, self.user)
await UsageService.record_usage_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertEqual('托盘库存版本无效', raised.exception.message)
mocks['add_usage'].assert_not_awaited()
@@ -1188,7 +1233,7 @@ class TestRecordUsageCore(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'get_pallet_by_qr_token', new=AsyncMock(return_value=None)),
self.assertRaises(PermissionException) as normal_missing,
):
await UsageService.record_usage_services(self.db, self.page, self.user)
await UsageService.record_usage_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertEqual('无权访问该托盘', normal_missing.exception.message)
self.db.rollback.assert_awaited_once()
@@ -1199,14 +1244,14 @@ class TestRecordUsageCore(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'get_pallet_by_qr_token', new=AsyncMock(return_value=None)),
self.assertRaises(ServiceException) as admin_missing,
):
await UsageService.record_usage_services(self.db, self.page, make_user(1))
await UsageService.record_usage_services(self.db, self.page, make_user(1), TestBatchScope.formal())
self.assertEqual('托盘不存在', admin_missing.exception.message)
self.db.rollback.assert_awaited_once()
self.db.reset_mock()
stack, mocks = self._patch_record_path(inventory=make_inventory(site_id=None))
with stack, self.assertRaises(PermissionException) as non_site:
await UsageService.record_usage_services(self.db, self.page, self.user)
await UsageService.record_usage_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertEqual('无权访问该托盘', non_site.exception.message)
mocks['pallet_lock'].assert_not_awaited()
self.assertEqual(2, self.db.rollback.await_count)
@@ -1329,14 +1374,15 @@ class TestUsageIdempotency(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'get_inventory_for_update', new=inventory_lock),
patch.object(OperationDao, 'add_usage_record', new=AsyncMock()) as add_usage,
):
result = await UsageService.record_usage_services(self.db, self.page, self.user)
result = await UsageService.record_usage_services(self.db, self.page, self.user, TestBatchScope.formal())
get_key.assert_awaited_once_with(
self.db,
'usage-key',
TestBatchScope.formal(),
site_ids=[9],
)
site_lock.assert_awaited_once_with(self.db, 9, for_update=True)
site_lock.assert_awaited_once_with(self.db, 9, TestBatchScope.formal(), for_update=True)
access.assert_awaited_once_with(self.db, self.user, 9, for_update=True)
inventory_lock.assert_not_awaited()
add_usage.assert_not_awaited()
@@ -1367,10 +1413,15 @@ class TestUsageIdempotency(unittest.IsolatedAsyncioTestCase):
patch.object(MasterDao, 'get_site', new=AsyncMock(return_value=make_site())),
patch.object(AccessService, 'assert_site_access', new=AsyncMock()),
):
result = await UsageService.record_usage_services(self.db, self.page, user)
result = await UsageService.record_usage_services(self.db, self.page, user, TestBatchScope.formal())
line_read.assert_awaited_once_with(self.db, 4)
get_key.assert_awaited_once_with(self.db, 'usage-key', site_ids=[9])
line_read.assert_awaited_once_with(self.db, 4, TestBatchScope.formal())
get_key.assert_awaited_once_with(
self.db,
'usage-key',
TestBatchScope.formal(),
site_ids=[9],
)
self.assertEqual(61, result.result.usage_id)
if user.user and user.user.admin:
scope_read.assert_not_awaited()
@@ -1384,7 +1435,7 @@ class TestUsageIdempotency(unittest.IsolatedAsyncioTestCase):
patch.object(InventoryDao, 'get_inventory_for_update', new=AsyncMock()) as inventory_lock,
self.assertRaises(ServiceException) as raised,
):
await UsageService.record_usage_services(self.db, self.page, self.user)
await UsageService.record_usage_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertIn('幂等键', raised.exception.message)
inventory_lock.assert_not_awaited()
@@ -1401,7 +1452,7 @@ class TestUsageIdempotency(unittest.IsolatedAsyncioTestCase):
patch.object(AccessService, 'assert_site_access', new=access),
self.assertRaises(PermissionException),
):
await UsageService.record_usage_services(self.db, self.page, self.user)
await UsageService.record_usage_services(self.db, self.page, self.user, TestBatchScope.formal())
access.assert_awaited_once_with(self.db, self.user, 9, for_update=True)
self.db.commit.assert_not_awaited()
@@ -1460,6 +1511,7 @@ class TestUsageIdempotency(unittest.IsolatedAsyncioTestCase):
self.db,
self.page,
self.user,
TestBatchScope.formal(),
)
except ServiceException as exc:
self.fail(f'精确并发重试被旧库存状态提前拒绝：{exc.message}')
@@ -1495,7 +1547,12 @@ class TestUsageIdempotency(unittest.IsolatedAsyncioTestCase):
mocks['filling_lock'].assert_awaited_once()
else:
mocks['filling_lock'].assert_not_awaited()
mocks['site_lock'].assert_awaited_once_with(self.db, 9, for_update=True)
mocks['site_lock'].assert_awaited_once_with(
self.db,
9,
TestBatchScope.formal(),
for_update=True,
)
mocks['line_lock'].assert_not_awaited()
mocks['add_usage'].assert_not_awaited()
mocks['add_event'].assert_not_awaited()
@@ -1541,7 +1598,9 @@ class TestUsageIdempotency(unittest.IsolatedAsyncioTestCase):
)
with stack:
try:
result = await UsageService.record_usage_services(self.db, self.page, self.user)
result = await UsageService.record_usage_services(
self.db, self.page, self.user, TestBatchScope.formal()
)
except ServiceException as exc:
self.fail(f'锁等待期间新增授权后未使用 fresh scope：{exc.message}')
@@ -1590,7 +1649,7 @@ class TestUsageIdempotency(unittest.IsolatedAsyncioTestCase):
)
with stack:
try:
await UsageService.record_usage_services(self.db, self.page, self.user)
await UsageService.record_usage_services(self.db, self.page, self.user, TestBatchScope.formal())
except PermissionException as exc:
self.assertEqual('无权访问该托盘', exc.message)
else:
@@ -1653,13 +1712,13 @@ class TestUsageIdempotency(unittest.IsolatedAsyncioTestCase):
self.db.rollback.side_effect = rollback
with stack, self.assertRaises(ServiceException) as raised:
await UsageService.record_usage_services(self.db, self.page, self.user)
await UsageService.record_usage_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertEqual('托盘二维码与库存不一致', raised.exception.message)
self.assertTrue(scanned.expired)
self.assertEqual(1, scanned.pallet_id_reads)
mocks['inventory_lock'].assert_awaited_once_with(self.db, 2)
mocks['pallet_lock'].assert_awaited_once_with(self.db, [2])
mocks['inventory_lock'].assert_awaited_once_with(self.db, 2, TestBatchScope.formal())
mocks['pallet_lock'].assert_awaited_once_with(self.db, [2], TestBatchScope.formal())
self.assertEqual(2, scope.await_count)
self.assertEqual(
[{'site_ids': [9]}, {'site_ids': [9]}],
@@ -1688,7 +1747,7 @@ class TestUsageIdempotency(unittest.IsolatedAsyncioTestCase):
access = mocks['access']
with stack:
try:
await UsageService.record_usage_services(self.db, self.page, self.user)
await UsageService.record_usage_services(self.db, self.page, self.user, TestBatchScope.formal())
except PermissionException as exc:
self.assertEqual('无权访问该使用记录', exc.message)
except ServiceException as exc:
@@ -1701,7 +1760,12 @@ class TestUsageIdempotency(unittest.IsolatedAsyncioTestCase):
[call.kwargs for call in key_read.await_args_list],
)
self.assertEqual(2, mocks['scope_read'].await_count)
mocks['site_lock'].assert_awaited_once_with(self.db, 9, for_update=True)
mocks['site_lock'].assert_awaited_once_with(
self.db,
9,
TestBatchScope.formal(),
for_update=True,
)
self.assertEqual([False, True], [call.kwargs.get('for_update', False) for call in access.await_args_list])
mocks['line_lock'].assert_not_awaited()
mocks['add_usage'].assert_not_awaited()
@@ -1734,7 +1798,7 @@ class TestUsageIdempotency(unittest.IsolatedAsyncioTestCase):
key_read = mocks['key_read']
with stack:
try:
await UsageService.record_usage_services(self.db, self.page, self.user)
await UsageService.record_usage_services(self.db, self.page, self.user, TestBatchScope.formal())
except ServiceException as exc:
self.assertEqual(
'使用失败，幂等键已被其他请求使用',
@@ -1768,7 +1832,7 @@ class TestUsageIdempotency(unittest.IsolatedAsyncioTestCase):
add_usage=add_usage,
)
with stack:
result = await UsageService.record_usage_services(self.db, self.page, self.user)
result = await UsageService.record_usage_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertIsInstance(result.result, UsageSuccessResponseModel)
self.assertEqual(
@@ -1800,7 +1864,7 @@ class TestUsageIdempotency(unittest.IsolatedAsyncioTestCase):
add_usage=AsyncMock(side_effect=integrity_error()),
)
with stack, self.assertRaises(ServiceException) as raised:
await UsageService.record_usage_services(self.db, self.page, self.user)
await UsageService.record_usage_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertTrue('幂等' in raised.exception.message or '冲突' in raised.exception.message)
self.assertEqual(
[{'site_ids': [9]}, {'site_ids': [9]}, {'site_ids': [9]}],
@@ -1818,7 +1882,7 @@ class TestUsageIdempotency(unittest.IsolatedAsyncioTestCase):
add_usage=AsyncMock(side_effect=integrity_error()),
)
with stack, self.assertRaises(PermissionException):
await UsageService.record_usage_services(self.db, self.page, self.user)
await UsageService.record_usage_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertEqual(3, scope.await_count)
self.assertEqual(2, key_read.await_count)
@@ -1835,7 +1899,7 @@ class TestUsageIdempotency(unittest.IsolatedAsyncioTestCase):
add_event=AsyncMock(side_effect=RuntimeError('event failed')),
)
with stack, self.assertRaises(RuntimeError):
await UsageService.record_usage_services(self.db, self.page, self.user)
await UsageService.record_usage_services(self.db, self.page, self.user, TestBatchScope.formal())
self.assertEqual(2, self.db.rollback.await_count)
self.db.commit.assert_not_awaited()
@@ -1845,7 +1909,7 @@ class TestUsageIdempotency(unittest.IsolatedAsyncioTestCase):
patch.object(UsageService, '_build_request_hash', side_effect=RuntimeError('hash failed')),
self.assertRaises(RuntimeError),
):
await UsageService.record_usage_services(self.db, self.page, self.user)
await UsageService.record_usage_services(self.db, self.page, self.user, TestBatchScope.formal())
self.db.rollback.assert_awaited_once()
self.db.commit.assert_not_awaited()