243 lines
7.6 KiB
JavaScript
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 ]);
|
|
});
|
|
});
|