'use strict'; const assert = require('node:assert/strict'); const PendingOrderService = require('../../../../../app/service/systemMethods/order/pendingOrder'); /** * 创建待处理订单储位分配系统方法测试上下文。 * * @param {Object} options 可选覆盖项。 * @param {Function} options.allocateStorageImpl 自定义储位分配实现。 * @return {{ ctx: Object, capture: Object, cacheStore: Map, service: PendingOrderService }} 测试上下文。 */ function createHarness(options = {}) { const capture = { request: null, }; const cacheStore = new Map(); const allocateStorageImpl = typeof options.allocateStorageImpl === 'function' ? options.allocateStorageImpl : null; const ctx = { app: { async getCacheAsync(cacheKey) { return cacheStore.get(cacheKey); }, async setCacheAsync(cacheKey, value) { cacheStore.set(cacheKey, value); }, }, user: { store_id: 100000, }, service: { systems: { orderStorageAllocation: { async allocateStorage(request) { capture.request = request; if (allocateStorageImpl) { return await allocateStorageImpl(request, capture); } return { code: 200, message: '储位分配完成', data: { ok: true, }, }; }, async cancelAllocateStorage(request) { capture.cancelRequest = request; return { code: 200, message: '取消分配完成', data: { ok: true, }, }; }, async syncOrderIds(request) { capture.syncRequest = request; return { code: 200, message: '同步已受理,当前仅透传 order_ids', data: { ok: true, }, }; }, }, }, }, logger: { info: () => {}, warn: () => {}, error: () => {}, }, }; return { ctx, capture, cacheStore, service: new PendingOrderService(ctx), }; } describe('test/app/service/systemMethods/order/pendingOrder.allocateStorage.test.js', () => { it('should return request_id immediately and delegate normalized input asynchronously', async () => { const { capture, service } = createHarness(); const result = await service.allocateStorage({ allowStorageLocation: true, ids: '1,2,3', }); assert.equal(result.flag, 'success'); assert.equal(result.warehouse_id, 100000); assert.equal(result.message, '请求已提交,后端处理中'); assert.match(result.request_id, /^storage_alloc_100000_\d+_[a-z0-9]+$/); await new Promise(resolve => setImmediate(resolve)); assert.equal(capture.request.allow_storage_location, true); assert.equal(capture.request.order_ids, '1,2,3'); assert.equal(typeof capture.request.progress_callback, 'function'); }); it('should query allocate storage progress by request_id after async task success', async () => { const { service } = createHarness(); const submitResult = await service.allocateStorage({ allow_storage_location: true, order_ids: [ 1, 2, 3 ], }); await new Promise(resolve => setImmediate(resolve)); await new Promise(resolve => setImmediate(resolve)); const progressResult = await service.allocateStorageProgress({ request_id: submitResult.request_id, }); assert.equal(progressResult.flag, 'success'); assert.equal(progressResult.message, 'ok'); assert.equal(progressResult.request_id, submitResult.request_id); assert.equal(progressResult.status, 'success'); assert.equal(progressResult.progress, 100); assert.equal(progressResult.total_count, 0); assert.equal(progressResult.processed_count, 0); assert.deepEqual(progressResult.result, { code: 200, message: '储位分配完成', data: { ok: true, }, }); assert.equal(typeof progressResult.update_time, 'number'); }); it('should return not_found when request_id does not exist in cache', async () => { const { service } = createHarness(); const result = await service.allocateStorageProgress({ requestId: 'not_exist_request_id', }); assert.equal(result.flag, 'success'); assert.equal(result.message, 'ok'); assert.equal(result.request_id, 'not_exist_request_id'); assert.equal(result.status, 'not_found'); assert.equal(result.progress, 0); }); it('should backfill progress from status for legacy cache payload without progress field', async () => { const { service, cacheStore } = createHarness(); const requestId = 'legacy_request_id'; cacheStore.set(service.getAllocateStorageTaskCacheKey(requestId), { request_id: requestId, status: 'running', update_time: Date.now(), }); const result = await service.allocateStorageProgress({ request_id: requestId, }); assert.equal(result.flag, 'success'); assert.equal(result.message, 'ok'); assert.equal(result.request_id, requestId); assert.equal(result.status, 'running'); assert.equal(result.progress, 50); assert.equal(result.total_count, 0); assert.equal(result.processed_count, 0); }); it('should report increasing progress and counters while allocation is running', async () => { let resolveFirstProgress; const firstProgressReady = new Promise(resolve => { resolveFirstProgress = resolve; }); let resolveSecondProgress; const secondProgressGate = new Promise(resolve => { resolveSecondProgress = resolve; }); let resolveAllocation; const allocationDone = new Promise(resolve => { resolveAllocation = resolve; }); const { service } = createHarness({ allocateStorageImpl: async request => { await request.progress_callback({ total_count: 4, processed_count: 1, }); resolveFirstProgress(); await secondProgressGate; await request.progress_callback({ total_count: 4, processed_count: 2, }); await allocationDone; await request.progress_callback({ total_count: 4, processed_count: 4, }); return { code: 200, message: '储位分配完成', data: { ok: true, }, }; }, }); const submitResult = await service.allocateStorage({ allow_storage_location: true, order_ids: [ 1, 2, 3, 4 ], }); await firstProgressReady; const firstRunningProgress = await service.allocateStorageProgress({ request_id: submitResult.request_id, }); assert.equal(firstRunningProgress.flag, 'success'); assert.equal(firstRunningProgress.status, 'running'); assert.equal(firstRunningProgress.total_count, 4); assert.equal(firstRunningProgress.processed_count, 1); assert.equal(firstRunningProgress.progress, 25); resolveSecondProgress(); await new Promise(resolve => setImmediate(resolve)); const runningProgress = await service.allocateStorageProgress({ request_id: submitResult.request_id, }); assert.equal(runningProgress.flag, 'success'); assert.equal(runningProgress.status, 'running'); assert.equal(runningProgress.total_count, 4); assert.equal(runningProgress.processed_count, 2); assert.equal(runningProgress.progress, 50); resolveAllocation(); await new Promise(resolve => setImmediate(resolve)); await new Promise(resolve => setImmediate(resolve)); const successProgress = await service.allocateStorageProgress({ request_id: submitResult.request_id, }); assert.equal(successProgress.flag, 'success'); assert.equal(successProgress.status, 'success'); assert.equal(successProgress.total_count, 4); assert.equal(successProgress.processed_count, 4); assert.equal(successProgress.progress, 100); }); it('should return failure when request_id is empty', async () => { const { service } = createHarness(); const result = await service.allocateStorageProgress({ request_id: ' ', }); assert.equal(result.flag, 'failure'); assert.equal(result.message, 'request_id 参数不能为空'); assert.equal(result.code, 400); }); it('should keep explainable progress when allocation fails after partial processing', async () => { const { service } = createHarness({ allocateStorageImpl: async request => { await request.progress_callback({ total_count: 4, processed_count: 1, }); throw new Error('模拟分配失败'); }, }); const submitResult = await service.allocateStorage({ allow_storage_location: true, order_ids: [ 1, 2, 3, 4 ], }); await new Promise(resolve => setImmediate(resolve)); await new Promise(resolve => setImmediate(resolve)); const failedProgress = await service.allocateStorageProgress({ request_id: submitResult.request_id, }); assert.equal(failedProgress.flag, 'success'); assert.equal(failedProgress.status, 'failed'); assert.equal(failedProgress.total_count, 4); assert.equal(failedProgress.processed_count, 1); assert.equal(failedProgress.progress, 25); assert.equal(failedProgress.error, '模拟分配失败'); }); it('should keep explainable progress when allocation is canceled', async () => { const { service } = createHarness({ allocateStorageImpl: async request => { await request.progress_callback({ total_count: 5, processed_count: 2, }); throw new Error('任务已取消'); }, }); const submitResult = await service.allocateStorage({ allow_storage_location: true, order_ids: [ 1, 2, 3, 4, 5 ], }); await new Promise(resolve => setImmediate(resolve)); await new Promise(resolve => setImmediate(resolve)); const canceledProgress = await service.allocateStorageProgress({ request_id: submitResult.request_id, }); assert.equal(canceledProgress.flag, 'success'); assert.equal(canceledProgress.status, 'failed'); assert.equal(canceledProgress.total_count, 5); assert.equal(canceledProgress.processed_count, 2); assert.equal(canceledProgress.progress, 40); assert.equal(canceledProgress.error, '任务已取消'); }); it('should forward only order IDs when canceling storage allocation', async () => { const { capture, service } = createHarness(); const result = await service.cancelAllocateStorage({ orderId: 7, }); assert.deepEqual(capture.cancelRequest, { order_ids: 7, }); assert.equal(result.flag, 'success'); assert.equal(result.message, '取消分配完成'); assert.equal(result.code, 200); assert.deepEqual(result.data, { ok: true, }); }); it('should forward only order ID aliases for cancel allocation', async () => { const { capture, service } = createHarness(); await service.cancelAllocateStorage({ orderIds: [ 8, 9 ], }); assert.deepEqual(capture.cancelRequest, { order_ids: [ 8, 9 ], }); }); it('should forward order_ids to the sync service without extra processing', async () => { const { capture, service } = createHarness(); const result = await service.syncOrderIds({ order_ids: [ 11, 12 ], }); // 异步模式:立即返回 request_id,service 层在 setImmediate 中调用 assert.equal(result.flag, 'success'); assert.match(result.request_id, /^sync_order_100000_\d+_[a-z0-9]+$/); assert.equal(result.warehouse_id, 100000); assert.ok(result.message.includes('已提交')); // 等待异步回调触发 await new Promise(resolve => setImmediate(resolve)); // service 层被正确调用 assert.deepEqual(capture.syncRequest.order_ids, [ 11, 12 ]); assert.equal(capture.syncRequest.warehouse_id, 100000); assert.equal(typeof capture.syncRequest.progress_callback, 'function'); }); it('should reject warehouse_id and warehouseId on the pending order entry', async () => { const { capture, service } = createHarness(); await assert.rejects( async () => await service.allocateStorage({ allow_storage_location: true, order_ids: [ 1 ], warehouse_id: 200000, }), /不再接受 warehouse_id \/ warehouseId/ ); await assert.rejects( async () => await service.allocateStorage({ allow_storage_location: true, order_ids: [ 1 ], warehouseId: 200000, }), /不再接受 warehouse_id \/ warehouseId/ ); assert.equal(capture.request, null); }); it('should not expose the legacy order.storageAllocation system method file anymore', () => { const legacyModule = require('../../../../../app/service/systemMethods/order/storageAllocation'); assert.equal(legacyModule, undefined); }); });