'use strict'; const assert = require('node:assert/strict'); const WaveService = require('../../../../../app/service/systemMethods/order/wave'); /** * 创建 batchAllocateStorage 轻量测试上下文。 * * @param {Object} options 初始化选项。 * @param {Array} [options.orderIds=[]] 波次内订单ID集合。 * @param {Function} [options.allocateStorageImpl] 自定义储位分配实现。 * @return {{ service: WaveService, cacheStore: Map, capture: Object }} 服务实例、缓存与调用记录。 */ function createHarness(options = {}) { const cacheStore = new Map(); const orderIds = Array.isArray(options.orderIds) ? options.orderIds : []; const allocateStorageImpl = typeof options.allocateStorageImpl === 'function' ? options.allocateStorageImpl : null; const capture = { allocateRequest: null, runningSnapshots: [], }; const ctx = { app: { config: {}, async setCacheAsync(key, value) { cacheStore.set(key, value); }, async getCacheAsync(key) { return cacheStore.get(key) || null; }, }, user: { store_id: 100000, }, logger: { info() {}, warn() {}, error() {}, }, model: {}, service: { systems: { orderStorageAllocation: { async allocateStorage(request) { capture.allocateRequest = request; if (allocateStorageImpl) { return await allocateStorageImpl(request, capture); } return { code: 200, message: '储位分配完成', data: { pending_order_ids: orderIds, allocated_order_ids: orderIds, shortage_order_ids: [], }, }; }, }, }, }, }; const service = new WaveService(ctx); service.getOrderModel = async () => ({ async findAll() { return orderIds.map(id => ({ id })); }, }); return { service, cacheStore, capture, }; } describe('test/app/service/systemMethods/order/wave.batchAllocateStorage.test.js', () => { it('should fail later task when another allocate-storage task is running in the same warehouse', async () => { let unblockFirstTask; const firstTaskWaiter = new Promise(resolve => { unblockFirstTask = resolve; }); const { service } = createHarness({ orderIds: [ 1, 2 ], allocateStorageImpl: async () => { await firstTaskWaiter; return { code: 200, message: '储位分配完成', data: { pending_order_ids: [ 1, 2 ], allocated_order_ids: [ 1, 2 ], shortage_order_ids: [], }, }; }, }); const firstTaskPromise = service.runBatchAllocateStorageTask({ taskId: 'task_running_same_warehouse_1', warehouseId: 100000, waveIds: [ 20 ], }); await new Promise(resolve => setImmediate(resolve)); await service.runBatchAllocateStorageTask({ taskId: 'task_running_same_warehouse_2', warehouseId: 100000, waveIds: [ 21 ], }); const conflictProgress = await service.getBatchAllocateStorageTaskProgress('task_running_same_warehouse_2'); assert.equal(conflictProgress.state, 'failed'); assert.equal(conflictProgress.error_code, 'WAVE_BATCH_ALLOCATE_STORAGE_WAREHOUSE_CONFLICT'); unblockFirstTask(); await firstTaskPromise; const firstTaskProgress = await service.getBatchAllocateStorageTaskProgress('task_running_same_warehouse_1'); assert.equal(firstTaskProgress.state, 'success'); }); it('should update running progress by progress_callback and keep running percent below 100', async () => { const { service, capture } = createHarness({ orderIds: [ 1, 2, 3, 4 ], allocateStorageImpl: async request => { await request.progress_callback({ total_count: 4, processed_count: 1, }); capture.runningSnapshots.push(await service.getBatchAllocateStorageTaskProgress('task_progress_running')); await request.progress_callback({ total_count: 4, processed_count: 4, }); capture.runningSnapshots.push(await service.getBatchAllocateStorageTaskProgress('task_progress_running')); return { code: 200, message: '储位分配完成', data: { pending_order_ids: [ 1, 2, 3, 4 ], allocated_order_ids: [ 1, 2, 3 ], shortage_order_ids: [ 4 ], }, }; }, }); await service.runBatchAllocateStorageTask({ taskId: 'task_progress_running', warehouseId: 100000, waveIds: [ 10 ], }); assert.equal(typeof capture.allocateRequest.progress_callback, 'function'); const firstRunning = capture.runningSnapshots[0]; assert.equal(firstRunning.state, 'running'); assert.equal(firstRunning.total_order_count, 4); assert.equal(firstRunning.processed_order_count, 1); assert.ok(firstRunning.progress_percent > 0); assert.ok(firstRunning.progress_percent < 100); const secondRunning = capture.runningSnapshots[1]; assert.equal(secondRunning.state, 'running'); assert.equal(secondRunning.total_order_count, 4); assert.equal(secondRunning.processed_order_count, 4); assert.equal(secondRunning.progress_percent, 99); assert.equal(capture.allocateRequest.business_id, 1); assert.deepEqual(capture.allocateRequest.business_ids, [ 1 ]); assert.deepEqual(capture.allocateRequest.orders, [ { order_id: 1, business_id: 1 }, { order_id: 2, business_id: 1 }, { order_id: 3, business_id: 1 }, { order_id: 4, business_id: 1 }, ]); }); it('should cache and return affected/allocated/shortage order ids after success', async () => { const { service } = createHarness({ orderIds: [ 1, 2, 3, 4 ], allocateStorageImpl: async request => { await request.progress_callback({ total_count: 3, processed_count: 2, }); return { code: 200, message: '储位分配完成,部分缺货', data: { pending_order_ids: [ 1, 2, 4 ], allocated_order_ids: [ 1, 2 ], shortage_order_ids: [ 4 ], }, }; }, }); await service.runBatchAllocateStorageTask({ taskId: 'task_success_result', warehouseId: 100000, waveIds: [ 11 ], }); const cachedProgress = await service.getBatchAllocateStorageTaskProgress('task_success_result'); assert.equal(cachedProgress.state, 'success'); assert.deepEqual(cachedProgress.affected_order_ids, [ 1, 2, 4 ]); assert.deepEqual(cachedProgress.allocated_order_ids, [ 1, 2 ]); assert.deepEqual(cachedProgress.shortage_order_ids, [ 4 ]); assert.equal(cachedProgress.affected_order_count, 3); assert.equal(cachedProgress.allocated_order_count, 2); assert.equal(cachedProgress.business_id, 1); assert.deepEqual(cachedProgress.business_ids, [ 1 ]); assert.equal(cachedProgress.result.business_id, 1); assert.deepEqual(cachedProgress.result.business_ids, [ 1 ]); const result = await service.batchAllocateStorageTaskProgress({ task_id: 'task_success_result', }); assert.equal(result.flag, 'success'); assert.equal(result.state, 'success'); assert.deepEqual(result.affected_order_ids, [ 1, 2, 4 ]); assert.deepEqual(result.allocated_order_ids, [ 1, 2 ]); assert.deepEqual(result.shortage_order_ids, [ 4 ]); assert.equal(result.affected_order_count, 3); assert.equal(result.allocated_order_count, 2); assert.equal(result.business_id, 1); assert.deepEqual(result.business_ids, [ 1 ]); }); });