WMS_MAIN/test/app/service/systemMethods/order/pendingOrder.allocateStorage.test.js
2026-04-27 16:09:26 +08:00

166 lines
4.3 KiB
JavaScript

'use strict';
const assert = require('node:assert/strict');
const PendingOrderService = require('../../../../../app/service/systemMethods/order/pendingOrder');
/**
* 创建待处理订单储位分配系统方法测试上下文。
*
* @return {{ ctx: Object, capture: Object, service: PendingOrderService }} 测试上下文。
*/
function createHarness() {
const capture = {
request: null,
};
const ctx = {
app: {},
user: {
store_id: 100000,
},
service: {
systems: {
orderStorageAllocation: {
async allocateStorage(request) {
capture.request = request;
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,
},
};
},
},
},
},
};
return {
ctx,
capture,
service: new PendingOrderService(ctx),
};
}
describe('test/app/service/systemMethods/order/pendingOrder.allocateStorage.test.js', () => {
it('should normalize allocation input before delegating to the shared storage allocation service', async () => {
const { capture, service } = createHarness();
const result = await service.allocateStorage({
allowStorageLocation: true,
ids: '1,2,3',
});
assert.deepEqual(capture.request, {
allow_storage_location: true,
order_ids: '1,2,3',
});
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 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 ],
});
assert.deepEqual(capture.syncRequest, {
order_ids: [ 11, 12 ],
});
assert.equal(result.flag, 'success');
assert.equal(result.message, '同步已受理,当前仅透传 order_ids');
assert.equal(result.code, 200);
assert.deepEqual(result.data, {
ok: true,
});
});
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);
});
});