WMS_MAIN/test/app/service/systemMethods/order/pendingOrder.allocateStorage.test.js
liufumingren 2817d17fc7 1
2026-07-06 00:33:12 +08:00

422 lines
13 KiB
JavaScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

'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<string, Object>, 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);
});
});