WMS_MAIN/test/app/service/stockout_order.cancel.test.js
liufumingren e19b5fc18c feat(order): 取消单据支持 CK 出库单与 RK 入库单
- 奇门 order.cancel:CK 组(PTCK/DBCK/B2BCK/QTCK/CGTH)委托 systems.stockoutOrder.cancel 取消出库单(仅 CREATED/PENDING 可取消,释放 QM_STOCKOUT 锁定,不回传);RK 组由裸改状态升级为复用 systems.storage.entry.cancel 完整作废流程(状态守卫 + 回退收货单占用 + 操作日志,已作废幂等成功)。

- openapi order.cancel:新增 CK 组与 RK 组路由,成功/失败文案与奇门口径一致。

- storage.stockout.cancel 改为委托共享实现,对外契约与文案不变,改为单事务 + 行锁。

- storage.entry.cancel 扩展入参能力(entryOrderCode 定位 / skipExternalSync / idempotent / notFoundMessage),系统方法入口行为不变。

- 文档:methods/{qimen,openapi,system}.json 及对应 changes 同步。

注:app/service/systems/stockout_order.js 与 methods/openapi.json 同时承载此前未提交的出库单(stockout)共享服务与文档,文件粒度无法拆分,一并纳入本次提交。
2026-09-13 02:24:18 +08:00

633 lines
22 KiB
JavaScript
Raw 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 StockoutOrderService = require('../../../app/service/systems/stockout_order');
const QimenOrderService = require('../../../app/service/qimenMethods/order');
const OpenapiOrderService = require('../../../app/service/openapiMethods/order');
const StorageStockoutService = require('../../../app/service/systemMethods/storage/stockout');
/**
* 构造最小出库单实例桩。
* @param {Object} overrides 覆盖字段。
* @return {Object} 出库单桩对象。
*/
function createStockoutOrder(overrides = {}) {
return {
id: 1,
stockout_order_code: 'SO-CK-001',
order_status: 'CREATED',
warehouse_id: 100000,
store_id: 1000000,
canCancel() {
return [ 'CREATED', 'PENDING' ].includes(this.order_status);
},
...overrides,
};
}
/**
* 构造共享取消服务(systems/stockout_order.js)测试桩。
* @param {Object} options 桩配置。
* @param {Object|null} [options.order] 出库单桩(null 表示查询不到)。
* @param {Array<Object>} [options.items] 出库单明细。
* @param {Array<Object>} [options.lockResults] 依次返回的 lockItemStorages 结果。
* @return {Object} service / calls / transaction。
*/
function createStockoutCancelHarness(options = {}) {
const calls = {
findOne: [],
findAll: [],
update: [],
lockItemStorages: [],
createOperationLogs: [],
commit: 0,
rollback: 0,
};
const transaction = {
LOCK: { UPDATE: 'UPDATE' },
async commit() { calls.commit += 1; },
async rollback() { calls.rollback += 1; },
};
const ctx = {
app: { config: {} },
logger: { info() {}, warn() {}, error() {}, debug() {} },
model: {
async transaction() { return transaction; },
OrderStockout: {
async findOne(query) {
calls.findOne.push(query);
return options.order === null ? null : (options.order || createStockoutOrder());
},
async update(values, query) {
calls.update.push({ values, query });
return [ 1 ];
},
},
OrderStockoutItems: {
async findAll(query) {
calls.findAll.push(query);
return options.items === undefined ? [] : options.items;
},
},
},
service: {
systems: {
stockStore: {
async lockItemStorages(stockId, qty, tx, oversell, meta) {
calls.lockItemStorages.push({ stockId, qty, tx, oversell, meta });
return options.lockResults && options.lockResults.length > 0
? options.lockResults.shift()
: { success: true };
},
},
operationLog: {
async createOperationLogs(list, opts) {
calls.createOperationLogs.push({ list, opts });
return [];
},
},
},
},
};
const service = new StockoutOrderService(ctx);
return { service, calls, transaction };
}
/**
* 构造奇门 order 服务测试桩(仅提供 stockoutOrder.cancel 委托桩)。
* @param {Object} options 桩配置。
* @return {Object} service / calls。
*/
function createQimenOrderHarness(options = {}) {
const calls = [];
const ctx = {
app: { config: {} },
logger: { info() {}, warn() {}, error() {}, debug() {} },
service: {
systems: {
stockoutOrder: {
async cancel(data, opts) {
calls.push({ data, opts });
return options.stockoutCancelResult || { flag: 'success', code: 1, message: '取消出库单成功' };
},
},
},
},
model: {
OrderDeliveryFactory: {
async getCurrentModel() {
throw new Error('CK 取消不应访问 delivery 模型');
},
},
},
};
const service = new QimenOrderService(ctx);
service.setInfo(1000000, 100000, 'app-key', 'customer-id', 'warehouse-code');
return { service, calls };
}
/**
* 构造 openapi order 服务测试桩(仅提供 stockoutOrder.cancel 委托桩与可选模型桩)。
* @param {Object} options 桩配置。
* @return {Object} service / calls。
*/
function createOpenapiOrderHarness(options = {}) {
const calls = [];
const ctx = {
app: { config: {} },
logger: { info() {}, warn() {}, error() {}, debug() {} },
service: {
systems: {
stockoutOrder: {
async cancel(data, opts) {
calls.push({ data, opts });
return options.stockoutCancelResult || { flag: 'success', code: 1, message: '取消出库单成功' };
},
},
},
},
model: options.model || {},
};
const service = new OpenapiOrderService(ctx);
service.setInfo(1000000, 100000, 'APP-KEY', null, '100000');
return { service, calls };
}
/**
* 构造 systemMethods/storage/stockout 服务测试桩。
* @param {Object} options 桩配置。
* @return {Object} service / calls。
*/
function createStorageStockoutHarness(options = {}) {
const calls = [];
const ctx = {
app: { config: {} },
logger: { info() {}, warn() {}, error() {}, debug() {} },
user: options.user === undefined
? { store_id: 100000, employees_id: 9, employees_name: '测试仓管' }
: options.user,
service: {
systems: {
stockoutOrder: {
async cancel(data, opts) {
calls.push({ data, opts });
return options.stockoutCancelResult === undefined
? {
flag: 'success',
code: 1,
message: '取消出库单成功',
id: 11,
stockout_order_code: 'SO-1',
order_status: 'CANCELLED',
}
: options.stockoutCancelResult;
},
},
},
},
};
const service = new StorageStockoutService(ctx);
return { service, calls };
}
describe('test/app/service/stockout_order.cancel.test.js', () => {
describe('systems.stockoutOrder.cancel 共享取消实现', () => {
it('出库单不存在时失败且不释放库存', async () => {
const { service, calls } = createStockoutCancelHarness({ order: null });
const result = await service.cancel(
{ stockoutOrderCode: 'SO-NOT-FOUND' },
{ storeId: 1000000, warehouseId: 100000, operatorLabel: 'qimen:customer-id' }
);
assert.equal(result.flag, 'failure');
assert.equal(result.message, '未找到对应的出库单');
assert.equal(calls.findOne.length, 1);
assert.equal(calls.rollback, 1);
assert.equal(calls.lockItemStorages.length, 0);
assert.equal(calls.update.length, 0);
assert.equal(calls.commit, 0);
});
it('已 CANCELLED 出库单幂等返回成功,不重复释放库存', async () => {
const { service, calls } = createStockoutCancelHarness({
order: createStockoutOrder({ order_status: 'CANCELLED' }),
items: [{ stock_id: 11, plan_qty: 5 }],
});
const result = await service.cancel(
{ stockoutOrderCode: 'SO-CK-001' },
{ storeId: 1000000, warehouseId: 100000, operatorLabel: 'qimen:customer-id' }
);
assert.equal(result.flag, 'success');
assert.equal(result.message, '取消出库单成功');
assert.equal(result.order_status, 'CANCELLED');
assert.equal(calls.rollback, 1);
assert.equal(calls.lockItemStorages.length, 0);
assert.equal(calls.update.length, 0);
assert.equal(calls.commit, 0);
});
it('CREATED 出库单取消成功:按单号定位、释放 QM_STOCKOUT 锁定、置 CANCELLED 并写操作日志', async () => {
const { service, calls, transaction } = createStockoutCancelHarness({
items: [
{ stock_id: 11, plan_qty: 5 },
{ stock_id: 12, plan_qty: 0 },
],
});
const result = await service.cancel(
{ stockoutOrderCode: 'SO-CK-001' },
{ storeId: 1000000, warehouseId: 100000, operatorLabel: 'qimen:customer-id' }
);
assert.equal(result.flag, 'success');
assert.equal(result.message, '取消出库单成功');
assert.equal(result.id, 1);
assert.equal(result.stockout_order_code, 'SO-CK-001');
assert.equal(result.order_status, 'CANCELLED');
// 定位条件:仓库 + 货主 + 软删除过滤 + 行锁
assert.deepEqual(calls.findOne[0].where, {
warehouse_id: 100000,
store_id: 1000000,
deleted_at: null,
stockout_order_code: 'SO-CK-001',
});
assert.equal(calls.findOne[0].lock, 'UPDATE');
assert.equal(calls.findOne[0].transaction, transaction);
// 库存锁定释放:负数量 + QM_STOCKOUT 标记
assert.equal(calls.lockItemStorages.length, 1);
assert.equal(calls.lockItemStorages[0].stockId, 11);
assert.equal(calls.lockItemStorages[0].qty, -5);
assert.deepEqual(calls.lockItemStorages[0].meta, {
orderType: 'QM_STOCKOUT',
orderNo: 'SO-CK-001',
orderId: 1,
remark: '出库单取消释放锁定',
});
// 状态更新 + 操作日志同事务
assert.equal(calls.update.length, 1);
assert.equal(calls.update[0].values.order_status, 'CANCELLED');
assert.equal(calls.update[0].values.sync_message, '已取消');
assert.equal(calls.update[0].query.transaction, transaction);
assert.equal(calls.createOperationLogs.length, 1);
assert.equal(calls.createOperationLogs[0].list[0].businessType, 'stockout');
assert.equal(calls.createOperationLogs[0].list[0].operationCode, 'STOCKOUT_CANCEL');
assert.equal(calls.createOperationLogs[0].list[0].operator.name, 'qimen:customer-id');
assert.equal(calls.createOperationLogs[0].list[0].extras.message, '出库单已取消,释放锁定库存 5');
assert.equal(calls.commit, 1);
});
it('仅传 id 时按 id + warehouse 定位(storeId 为空不参与定位条件)', async () => {
const { service, calls } = createStockoutCancelHarness({
order: createStockoutOrder({ id: 11 }),
});
const result = await service.cancel(
{ id: 11 },
{ storeId: null, warehouseId: 100000, operatorLabel: 'system' }
);
assert.equal(result.flag, 'success');
assert.deepEqual(calls.findOne[0].where, {
warehouse_id: 100000,
deleted_at: null,
id: 11,
});
});
it('COMPLETED 状态守卫拦截,不释放库存', async () => {
const { service, calls } = createStockoutCancelHarness({
order: createStockoutOrder({ order_status: 'COMPLETED' }),
items: [{ stock_id: 11, plan_qty: 5 }],
});
const result = await service.cancel(
{ stockoutOrderCode: 'SO-CK-001' },
{ storeId: 1000000, warehouseId: 100000 }
);
assert.equal(result.flag, 'failure');
assert.equal(result.message, '出库单当前状态(COMPLETED)不允许取消');
assert.equal(calls.lockItemStorages.length, 0);
assert.equal(calls.update.length, 0);
assert.equal(calls.commit, 0);
assert.equal(calls.rollback, 1);
});
it('TRANSFERRED 状态守卫拦截,不释放库存', async () => {
const { service, calls } = createStockoutCancelHarness({
order: createStockoutOrder({ order_status: 'TRANSFERRED' }),
items: [{ stock_id: 11, plan_qty: 5 }],
});
const result = await service.cancel(
{ stockoutOrderCode: 'SO-CK-001' },
{ storeId: 1000000, warehouseId: 100000 }
);
assert.equal(result.flag, 'failure');
assert.equal(result.message, '出库单当前状态(TRANSFERRED)不允许取消');
assert.equal(calls.lockItemStorages.length, 0);
assert.equal(calls.update.length, 0);
});
it('锁定已释放(释放数量超过已锁定库存)视为幂等跳过,仍取消成功', async () => {
const { service, calls } = createStockoutCancelHarness({
items: [{ stock_id: 11, plan_qty: 5 }],
lockResults: [{ success: false, error: '释放数量超过已锁定库存' }],
});
const result = await service.cancel(
{ stockoutOrderCode: 'SO-CK-001' },
{ storeId: 1000000, warehouseId: 100000 }
);
assert.equal(result.flag, 'success');
assert.equal(calls.update.length, 1);
assert.equal(calls.update[0].values.order_status, 'CANCELLED');
assert.equal(calls.createOperationLogs[0].list[0].extras.message, '出库单已取消,释放锁定库存 0');
assert.equal(calls.commit, 1);
});
it('库存释放硬失败时取消失败并回滚', async () => {
const { service, calls } = createStockoutCancelHarness({
items: [{ stock_id: 11, plan_qty: 5 }],
lockResults: [{ success: false, error: '库存不足' }],
});
const result = await service.cancel(
{ stockoutOrderCode: 'SO-CK-001' },
{ storeId: 1000000, warehouseId: 100000 }
);
assert.equal(result.flag, 'failure');
assert.equal(result.message, '取消失败:库存11释放锁定失败: 库存不足');
assert.equal(calls.rollback, 1);
assert.equal(calls.update.length, 0);
assert.equal(calls.commit, 0);
});
it('缺少仓库上下文与出库单号时分别返回对应文案', async () => {
const { service } = createStockoutCancelHarness();
const noWarehouse = await service.cancel({ stockoutOrderCode: 'SO-CK-001' }, {});
assert.equal(noWarehouse.flag, 'failure');
assert.equal(noWarehouse.message, '缺少仓库上下文');
const noCode = await service.cancel({}, { storeId: 1000000, warehouseId: 100000 });
assert.equal(noCode.flag, 'failure');
assert.equal(noCode.message, '出库单号不能为空');
});
});
describe('奇门 order.cancel CK 组路由', () => {
const CK_TYPES = [ 'PTCK', 'DBCK', 'B2BCK', 'QTCK', 'CGTH' ];
for (const ckType of CK_TYPES) {
it(`orderType=${ckType} 路由到出库单取消而非 delivery 取消`, async () => {
const { service, calls } = createQimenOrderHarness();
const result = await service.cancel({
request: { orderType: ckType, orderCode: 'SO-CK-001' },
});
assert.equal(result.flag, 'success');
assert.equal(result.message, '取消出库单成功');
assert.equal(calls.length, 1);
assert.deepEqual(calls[0].data, { stockoutOrderCode: 'SO-CK-001' });
assert.equal(calls[0].opts.storeId, 1000000);
assert.equal(calls[0].opts.warehouseId, 100000);
assert.equal(calls[0].opts.operatorLabel, 'qimen:customer-id');
});
}
it('CK 组缺 orderCode 时返回「出库单号不能为空」', async () => {
const { service, calls } = createQimenOrderHarness();
const result = await service.cancel({
request: { orderType: 'PTCK', orderCode: ' ' },
});
assert.equal(result.flag, 'failure');
assert.equal(result.message, '出库单号不能为空');
assert.equal(calls.length, 0);
});
it('ORDER 组(JYCK)仍走 delivery 取消分支', async () => {
// 复用真实 ORDER 分支桩:delivery 查询不到订单时返回「未找到对应的订单」
const modelCalls = { findOne: 0, stockoutCancel: 0 };
const transaction = {
LOCK: { UPDATE: 'UPDATE' },
async commit() {
modelCalls.commit += 1;
},
async rollback() {
modelCalls.rollback += 1;
},
};
const ctx = {
app: { config: {} },
logger: { info() {}, warn() {}, error() {}, debug() {} },
service: {
systems: {
stockoutOrder: {
async cancel() {
modelCalls.stockoutCancel += 1;
return { flag: 'success' };
},
},
},
},
model: {
async transaction() { return transaction; },
OrderDeliveryFactory: {
async getCurrentModel() {
return {
async findOne() {
modelCalls.findOne += 1;
return null;
},
};
},
async getDispatchModel() {
return {
async findOne() {
return null;
},
};
},
},
},
};
const service = new QimenOrderService(ctx);
service.setInfo(1000000, 100000, 'app-key', 'customer-id', 'warehouse-code');
const result = await service.cancel({
request: { orderType: 'JYCK', orderCode: 'OD-001' },
});
assert.equal(result.flag, 'failure');
assert.equal(result.message, '未找到对应的订单');
assert.equal(modelCalls.findOne, 1);
assert.equal(modelCalls.stockoutCancel, 0);
});
});
describe('openapi order.cancel CK 组路由', () => {
const CK_TYPES = [ 'PTCK', 'DBCK', 'B2BCK', 'QTCK', 'CGTH' ];
for (const ckType of CK_TYPES) {
it(`orderType=${ckType}(含小写归一化)路由到出库单取消`, async () => {
const { service, calls } = createOpenapiOrderHarness();
const result = await service.cancel({
body: { orderType: ckType.toLowerCase(), orderCode: 'SO-CK-001' },
query: {},
});
assert.equal(result.flag, 'success');
assert.equal(result.message, '取消出库单成功');
assert.equal(calls.length, 1);
assert.deepEqual(calls[0].data, { stockoutOrderCode: 'SO-CK-001' });
assert.equal(calls[0].opts.storeId, 1000000);
assert.equal(calls[0].opts.warehouseId, 100000);
assert.equal(calls[0].opts.operatorLabel, 'openapi:APP-KEY');
});
}
it('非支持类型仍返回「暂不支持该订单类型的取消操作」', async () => {
const { service, calls } = createOpenapiOrderHarness();
const result = await service.cancel({
body: { orderType: 'XTRK', orderCode: 'SO-CK-001' },
query: {},
});
assert.equal(result.flag, 'failure');
assert.equal(result.message, '暂不支持该订单类型的取消操作');
assert.equal(calls.length, 0);
});
it('ORDER 组(JYCK)缺 orderCode 仍返回原「orderCode 参数缺失」', async () => {
const { service, calls } = createOpenapiOrderHarness();
const result = await service.cancel({
body: { orderType: 'JYCK', orderCode: ' ' },
query: {},
});
assert.equal(result.flag, 'failure');
assert.equal(result.message, 'orderCode 参数缺失');
assert.equal(calls.length, 0);
});
it('ORDER 组(JYCK)仍走 delivery 取消分支', async () => {
const modelCalls = { deliveryFindOne: 0 };
const transaction = {
LOCK: { UPDATE: 'UPDATE' },
async commit() {
modelCalls.commit += 1;
},
async rollback() {
modelCalls.rollback += 1;
},
};
const { service, calls } = createOpenapiOrderHarness({
model: {
async transaction() { return transaction; },
OrderDeliveryFactory: {
async getCurrentModel() {
return {
async findOne() {
modelCalls.deliveryFindOne += 1;
return null;
},
};
},
},
},
});
const result = await service.cancel({
body: { orderType: 'JYCK', orderCode: 'OD-1' },
query: {},
});
assert.equal(result.flag, 'failure');
assert.equal(result.message, '未找到对应的订单');
assert.equal(modelCalls.deliveryFindOne, 1);
assert.equal(calls.length, 0);
});
});
describe('systemMethods storage.stockout.cancel 委托契约', () => {
it('缺 id / 缺仓库上下文保持原契约', async () => {
const { service, calls } = createStorageStockoutHarness();
const noId = await service.cancel({});
assert.equal(noId.flag, 'failure');
assert.equal(noId.message, '缺少出库单ID');
const { service: noWhService, calls: noWhCalls } = createStorageStockoutHarness({
user: { store_id: 0 },
});
const noWarehouse = await noWhService.cancel({ id: 11 });
assert.equal(noWarehouse.flag, 'failure');
assert.equal(noWarehouse.message, '缺少仓库上下文');
assert.equal(calls.length, 0);
assert.equal(noWhCalls.length, 0);
});
it('共享层「未找到对应的出库单」映射为「出库单不存在」', async () => {
const { service, calls } = createStorageStockoutHarness({
stockoutCancelResult: { flag: 'failure', code: 0, message: '未找到对应的出库单' },
});
const result = await service.cancel({ id: 11 });
assert.equal(result.flag, 'failure');
assert.equal(result.message, '出库单不存在');
assert.equal(calls.length, 1);
assert.deepEqual(calls[0].data, { id: 11 });
assert.equal(calls[0].opts.warehouseId, 100000);
assert.equal(calls[0].opts.storeId, null);
assert.equal(calls[0].opts.operatorLabel, '测试仓管');
});
it('状态守卫文案原样透出', async () => {
const { service } = createStorageStockoutHarness({
stockoutCancelResult: { flag: 'failure', code: 0, message: '出库单当前状态(COMPLETED)不允许取消' },
});
const result = await service.cancel({ id: 11 });
assert.equal(result.flag, 'failure');
assert.equal(result.message, '出库单当前状态(COMPLETED)不允许取消');
});
it('成功时保持「取消成功」契约并返回 id / 单号 / 状态', async () => {
const { service } = createStorageStockoutHarness();
const result = await service.cancel({ id: 11 });
assert.equal(result.flag, 'success');
assert.equal(result.message, '取消成功');
assert.equal(result.id, 11);
assert.equal(result.stockout_order_code, 'SO-1');
assert.equal(result.order_status, 'CANCELLED');
});
});
});