"""真实 MySQL 验收：仅允许显式指定的隔离演练库，绝不写开发/生产库。 运行前将备份恢复并迁移到 shierfeng_rehearsal_20261008_* 库，再设置 SHIERFENG_MYSQL_FLOW_TEST_DATABASE。测试只新建独立测试批次，保留现场用于复核。 """ import asyncio import os import re import secrets import unittest from datetime import date, datetime, timedelta from unittest.mock import patch from sqlalchemy import func, select, update from sqlalchemy.engine import URL from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine from config.env import DataBaseConfig from exceptions.exception import PermissionException, ServiceException from module_admin.entity.do import user_do # noqa: F401 from module_business.entity.do.master_do import ( BizCustomer, BizCustomerSite, BizPallet, BizStrain, BizTunnel, BizWarehouse, ) from module_business.entity.do.operation_do import ( BizPalletEvent, BizPalletInventory, BizReturnOrder, BizShipmentOrder, BizUsageRecord, ) from module_business.entity.do.test_batch_do import BizTestBatch from module_business.dao.inventory_dao import InventoryDao from module_business.dao.usage_fifo_dao import UsageFifoDao from module_business.domain.test_batch_scope import TestBatchScope from module_business.entity.vo.operation_vo import ( ConfirmCommandModel, FillingCreateModel, ReturnConfirmModel, ReturnRequestModel, ShipmentCreateModel, TunnelEntryCreateModel, UsageCreateModel, ) from module_business.entity.vo.shipment_receipt_vo import ShipmentReceiptCommandModel from module_business.entity.vo.report_vo import ( ConsumptionReportQueryModel, PalletInventoryReportQueryModel, PalletTraceReportQueryModel, ReturnReportQueryModel, ) from module_business.service.filling_service import FillingService from module_business.service.return_service import ReturnService from module_business.service.report_service import ReportService from module_business.service.shipment_label_service import ShipmentLabelService from module_business.service.shipment_receipt_service import ShipmentReceiptService from module_business.service.shipment_service import ShipmentService from module_business.service.usage_fifo_service import UsageFifoService from module_business.service.usage_service import UsageService from tests.module_business.test_batch_fixtures import make_admin, make_current_user, make_test_scope @unittest.skipUnless(os.environ.get('SHIERFENG_MYSQL_FLOW_TEST_DATABASE'), '需显式指定隔离MySQL演练库') class TestMaterialFlowMysql(unittest.IsolatedAsyncioTestCase): async def asyncSetUp(self): database = os.environ['SHIERFENG_MYSQL_FLOW_TEST_DATABASE'] if not re.fullmatch(r'shierfeng_rehearsal_20261008_[a-zA-Z0-9_]+', database): raise RuntimeError('只允许隔离演练库，拒绝写开发/生产数据库') if DataBaseConfig.db_host not in ('127.0.0.1', 'localhost'): raise RuntimeError('只允许本机MySQL') self.engine = create_async_engine(URL.create( 'mysql+asyncmy', username=DataBaseConfig.db_username, password=DataBaseConfig.db_password, host=DataBaseConfig.db_host, port=DataBaseConfig.db_port, database=database, query={'charset': 'utf8mb4'}, ), echo=False) self.sessions = async_sessionmaker(self.engine, autoflush=False) self.admin = make_admin() self.tag = 'FIFO-' + secrets.token_hex(6) async with self.sessions() as db: batch = BizTestBatch(batch_code=self.tag, batch_name='迁移隔离验收', status='ACTIVE') db.add(batch) await db.flush() self.scope = make_test_scope(batch.batch_id) self.batch_id = batch.batch_id warehouse = BizWarehouse(warehouse_code=self.tag, warehouse_name='验收仓库', test_batch_id=self.batch_id) customer = BizCustomer(customer_code=self.tag, customer_name='验收客户', test_batch_id=self.batch_id) strain = BizStrain(strain_code=self.tag, strain_name='验收品种', test_batch_id=self.batch_id) db.add_all([warehouse, customer, strain]) await db.flush() site = BizCustomerSite(customer_id=customer.customer_id, site_code=self.tag, site_name='验收现场', test_batch_id=self.batch_id) db.add(site) await db.flush() tunnel = BizTunnel(site_id=site.site_id, tunnel_code=self.tag, tunnel_name='验收隧道', test_batch_id=self.batch_id) db.add(tunnel) self.pallets = [] for index in (1, 2): pallet = BizPallet(pallet_code=f'{self.tag}-{index}', qr_token=f'{self.tag}/qr/{index}', capacity_packages=100, asset_status='0', test_batch_id=self.batch_id) db.add(pallet) await db.flush() db.add(BizPalletInventory(pallet_id=pallet.pallet_id, warehouse_id=warehouse.warehouse_id, flow_state='EMPTY_IN_WAREHOUSE', remaining_packages=0, version=0, updated_at=datetime.now(), test_batch_id=self.batch_id)) self.pallets.append((pallet.pallet_id, pallet.pallet_code, pallet.qr_token)) await db.flush() self.warehouse_id, self.site_id = warehouse.warehouse_id, site.site_id self.strain_id, self.tunnel_id = strain.strain_id, tunnel.tunnel_id await db.commit() async def asyncTearDown(self): await self.engine.dispose() async def call(self, method, *args, user=None): async with self.sessions() as db: return await method(db, *args, user or self.admin, self.scope) async def scalar(self, statement): async with self.sessions() as db: return await db.scalar(statement) async def test_full_receipt_fifo_mix_return_and_concurrent_retry(self): p1, p2 = self.pallets for index, pallet in enumerate(self.pallets, 1): await self.call(FillingService.fill_pallet_services, FillingCreateModel( qrToken=pallet[2], warehouseId=self.warehouse_id, strainId=self.strain_id, batchNo=f'{self.tag}-B{index}', productionDate='2026-10-01', expiryDate='2027-04-01', packageSpec='标准包', initialPackages=100, idempotencyKey=f'{self.tag}-fill-{index}', )) await self.call(ShipmentService.add_shipment_services, ShipmentCreateModel( sourceWarehouseId=self.warehouse_id, targetSiteId=self.site_id, palletIds=[p1[0], p2[0]], )) shipment_id = await self.scalar(select(BizShipmentOrder.shipment_id).where( BizShipmentOrder.test_batch_id == self.batch_id)) await self.call(ShipmentService.confirm_shipment_services, shipment_id, ConfirmCommandModel(idempotencyKey=self.tag + '-ship')) labels = await self.call(ShipmentLabelService.get_labels_services, shipment_id) self.assertEqual({l.pallet_code for l in labels}, {p1[1], p2[1]}) self.assertTrue(all(l.production_date == date(2026, 10, 1) and l.package_qty == 100 for l in labels)) entry = TunnelEntryCreateModel(qrToken=p2[2], tunnelId=self.tunnel_id, idempotencyKey=self.tag+'-entry2') with self.assertRaises(ServiceException): await self.call(UsageService.enter_tunnel_services, entry) # 在途不允许使用 receipt = ShipmentReceiptCommandModel(scannedPalletIds=[p1[0], p2[0]], idempotencyKey=self.tag+'-receive') with self.assertRaises(PermissionException): await self.call(ShipmentReceiptService.confirm_services, shipment_id, receipt, user=make_current_user(7)) await self.call(ShipmentReceiptService.confirm_services, shipment_id, receipt) # 两次实际到货的排序边界夹具，仅改本演练批次，不造开发库历史时间。 async with self.sessions() as db: inventory = await db.get(BizPalletInventory, p1[0]) inventory.site_arrived_at -= timedelta(days=1) await db.commit() async with self.sessions() as db: advice = await UsageFifoService.recommendation( db, p2[1], self.admin, self.scope, tunnel_id=self.tunnel_id) self.assertTrue(advice.requires_skip_reason) self.assertEqual(advice.recommended.pallet_id, p1[0]) with self.assertRaises(ServiceException) as error: await self.call(UsageService.enter_tunnel_services, entry) self.assertEqual(error.exception.data, 'FIFO_SKIP_REASON_REQUIRED') self.assertIsNone(await self.scalar(select(BizPalletInventory.tunnel_id).where(BizPalletInventory.pallet_id==p2[0]))) entry = entry.model_copy(update={'fifo_skip_reason': '工艺混批'}) await self.call(UsageService.enter_tunnel_services, entry) await self.call(UsageService.enter_tunnel_services, entry) # 已提交入隧幂等分支也不得触发过期加载 usage = UsageCreateModel(qrToken=p2[2], tunnelId=self.tunnel_id, usedPackages=20, idempotencyKey=self.tag+'-usage2') with self.assertRaises(ServiceException) as error: await self.call(UsageService.record_usage_services, usage) self.assertEqual(error.exception.data, 'FIFO_SKIP_REASON_REQUIRED') self.assertEqual(await self.scalar(select(BizPalletInventory.remaining_packages).where(BizPalletInventory.pallet_id==p2[0])),100) usage = usage.model_copy(update={'fifo_skip_reason': '工艺混批'}) # 独立MySQL连接同时重放相同业务命令，只能产生一条事实和一次扣减。 results = await asyncio.wait_for(asyncio.gather(*( self.call(UsageService.record_usage_services, usage) for _ in range(3) )), timeout=20) self.assertTrue(all(result.result.remaining_packages == 80 for result in results)) self.assertEqual(await self.scalar(select(func.count()).select_from(BizUsageRecord).where(BizUsageRecord.test_batch_id==self.batch_id)),1) record = await self.scalar(select(BizUsageRecord).where(BizUsageRecord.test_batch_id==self.batch_id)) self.assertEqual(record.fifo_skip_reason, '工艺混批') self.assertEqual(record.fifo_recommendation['palletCode'], p1[1]) with self.assertRaises(ServiceException): await self.call(UsageService.record_usage_services, usage.model_copy(update={'fifo_skip_reason':'更换原因'})) await self.call(UsageService.enter_tunnel_services, TunnelEntryCreateModel( qrToken=p1[2], tunnelId=self.tunnel_id, idempotencyKey=self.tag+'-entry1')) await self.call(UsageService.record_usage_services, UsageCreateModel( qrToken=p1[2], tunnelId=self.tunnel_id, usedPackages=20, idempotencyKey=self.tag+'-usage1')) traces = [await self.scalar(select(BizPalletInventory.trace_no).where(BizPalletInventory.pallet_id==p[0])) for p in self.pallets] self.assertTrue(traces[0] and traces[0] == traces[1]) await self.call(ShipmentReceiptService.confirm_services, shipment_id, receipt) self.assertEqual(await self.scalar(select(BizPalletInventory.remaining_packages).where(BizPalletInventory.pallet_id==p2[0])),80) await self.call(ReturnService.request_return_services, ReturnRequestModel( sourceSiteId=self.site_id, targetWarehouseId=self.warehouse_id, palletIds=[p2[0]], idempotencyKey=self.tag+'-return')) return_id = await self.scalar(select(BizReturnOrder.return_id).where(BizReturnOrder.test_batch_id==self.batch_id)) await self.call(ReturnService.confirm_return_services, return_id, ReturnConfirmModel( scannedPalletIds=[p2[0]], idempotencyKey=self.tag+'-return-confirm')) returned = await self.scalar(select(BizPalletInventory).where(BizPalletInventory.pallet_id==p2[0])) self.assertEqual((returned.remaining_packages,returned.warehouse_id,returned.flow_state), (80,self.warehouse_id,'FILLED_IN_WAREHOUSE')) self.assertIsNone(returned.site_arrived_at) self.assertEqual(await self.scalar(select(func.count()).select_from(BizPallet).where(BizPallet.test_batch_id==self.batch_id)),2) labels_after = await self.call(ShipmentLabelService.get_labels_services, shipment_id) self.assertEqual({(l.pallet_code,l.batch_no,l.package_qty) for l in labels_after}, {(p1[1],self.tag+'-B1',100),(p2[1],self.tag+'-B2',100)}) events = await self.scalar(select(func.count()).select_from(BizPalletEvent).where( BizPalletEvent.test_batch_id==self.batch_id, BizPalletEvent.fifo_skip_reason=='工艺混批')) self.assertEqual(events,2) consumption = await self.call(ReportService.get_consumption_report_list_services, ConsumptionReportQueryModel(tunnelId=self.tunnel_id)) self.assertEqual(consumption.total, 2) self.assertEqual(sum(row.used_packages for row in consumption.rows), 40) self.assertTrue(all(row.line_id is None and row.trace_no == traces[0] for row in consumption.rows)) self.assertEqual({row.batch_no for row in consumption.rows}, {self.tag+'-B1', self.tag+'-B2'}) returned_report = await self.call(ReportService.get_return_report_list_services, ReturnReportQueryModel(tunnelId=self.tunnel_id)) self.assertEqual(returned_report.total, 1) self.assertEqual(returned_report.rows[0].remaining_packages_snapshot, 80) inventory_report = await self.call(ReportService.get_pallet_inventory_list_services, PalletInventoryReportQueryModel()) self.assertEqual(inventory_report.total, 2) self.assertTrue(all(row.remaining_packages == 80 and row.production_date == date(2026, 10, 1) for row in inventory_report.rows)) trace_report = await self.call(ReportService.get_pallet_trace_list_services, PalletTraceReportQueryModel(palletCode=p2[1], pageSize=100)) entered = [row for row in trace_report.rows if row.event_type.value == 'TUNNEL_ENTERED'] self.assertEqual(len(entered), 1) self.assertEqual(entered[0].production_date, date(2026, 10, 1)) async def test_formal_two_pallet_lock_inversion_retries_without_wait_cycle(self): # 仅在隔离演练库将本方法新建的夹具设为正式模式；排除测试批次总锁掩盖并发问题。 async with self.sessions() as db: for model in (BizPalletInventory, BizPallet, BizTunnel, BizCustomerSite, BizCustomer, BizWarehouse, BizStrain): await db.execute(update(model).where(model.test_batch_id == self.batch_id).values(test_batch_id=None)) await db.commit() self.scope = TestBatchScope.formal() p1, p2 = self.pallets for index, pallet in enumerate(self.pallets): await self.call(FillingService.fill_pallet_services, FillingCreateModel( qrToken=pallet[2], warehouseId=self.warehouse_id, strainId=self.strain_id, batchNo=f'{self.tag}-B{index}', productionDate='2026-10-01', expiryDate='2027-04-01', packageSpec='标准包', initialPackages=100, idempotencyKey=f'{self.tag}-fill-{index}', )) # 已收货夹具，仍使用真实表、约束与后续全部真实SQL。 async with self.sessions() as db: for index, pallet in enumerate(self.pallets): inventory = await db.get(BizPalletInventory, pallet[0]) inventory.site_id, inventory.warehouse_id = self.site_id, None inventory.site_arrived_at = datetime(2026, 10, 6 + index) inventory.flow_state = 'AT_SITE_UNUSED' await db.commit() async def overlap(method, earlier, later): late_at_fifo, early_has_inventory = asyncio.Event(), asyncio.Event() real_fifo = UsageFifoDao.recommendation real_inventory = InventoryDao.get_inventory_for_update late_calls = 0 observations = [] inventory_attempts = [] async def scheduled_fifo(*args, **kwargs): nonlocal late_calls if asyncio.current_task().get_name() == 'fifo-later': late_calls += 1 if late_calls == 1: late_at_fifo.set() await early_has_inventory.wait() try: result = await real_fifo(*args, **kwargs) observations.append((asyncio.current_task().get_name(), 'candidate', result[0])) return result except Exception as error: observations.append((asyncio.current_task().get_name(), type(error).__name__, str(error))) raise async def scheduled_inventory(db, pallet_id, scope): inventory_attempts.append((asyncio.current_task().get_name(), pallet_id)) result = await real_inventory(db, pallet_id, scope) if asyncio.current_task().get_name() == 'fifo-earlier': early_has_inventory.set() return result with patch.object(UsageFifoDao, 'recommendation', new=scheduled_fifo), \ patch.object(InventoryDao, 'get_inventory_for_update', new=scheduled_inventory): late = asyncio.create_task(self.call(method, later), name='fifo-later') early = None try: await asyncio.wait_for(late_at_fifo.wait(), 5) early = asyncio.create_task(self.call(method, earlier), name='fifo-earlier') results = await asyncio.wait_for(asyncio.gather(late, early), 5) self.assertTrue(all(result.is_success for result in results)) # InnoDB 可以选择任一请求回滚；不能把“必须晚到请求重试”当业务约束。 self.assertGreaterEqual(len(inventory_attempts), 3, (observations, inventory_attempts)) for name in ('fifo-later', 'fifo-earlier'): self.assertLessEqual(sum(task_name == name for task_name, _ in inventory_attempts), 3) finally: for task in (late, early): if task is not None and not task.done(): task.cancel() await asyncio.gather(*(task for task in (late, early) if task is not None), return_exceptions=True) await overlap(UsageService.enter_tunnel_services, TunnelEntryCreateModel(qrToken=p1[2], tunnelId=self.tunnel_id, idempotencyKey=self.tag+'-entry1'), TunnelEntryCreateModel(qrToken=p2[2], tunnelId=self.tunnel_id, idempotencyKey=self.tag+'-entry2',fifoSkipReason='工艺混批')) await overlap(UsageService.record_usage_services, UsageCreateModel(qrToken=p1[2], tunnelId=self.tunnel_id, usedPackages=20,idempotencyKey=self.tag+'-usage1'), UsageCreateModel(qrToken=p2[2], tunnelId=self.tunnel_id, usedPackages=20,idempotencyKey=self.tag+'-usage2',fifoSkipReason='工艺混批')) for pallet in self.pallets: self.assertEqual(await self.scalar(select(BizPalletInventory.remaining_packages).where(BizPalletInventory.pallet_id==pallet[0])),80) self.assertEqual(await self.scalar(select(func.count()).select_from(BizUsageRecord).where(BizUsageRecord.pallet_id==pallet[0])),1)