WMS_MAIN/test/app/service/systemMethods/order/wave.batchAllocateStorage.test.js

243 lines
7.6 KiB
JavaScript

'use strict';
const assert = require('node:assert/strict');
const WaveService = require('../../../../../app/service/systemMethods/order/wave');
/**
* 创建 batchAllocateStorage 轻量测试上下文。
*
* @param {Object} options 初始化选项。
* @param {Array<number>} [options.orderIds=[]] 波次内订单ID集合。
* @param {Function} [options.allocateStorageImpl] 自定义储位分配实现。
* @return {{ service: WaveService, cacheStore: Map<string, Object>, 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 ]);
});
});