WMS_MAIN/test/app/service/entry_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

760 lines
26 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 StorageEntryService = require('../../../app/service/systems/storage/entry');
const QimenOrderService = require('../../../app/service/qimenMethods/order');
const OpenapiOrderService = require('../../../app/service/openapiMethods/order');
/** RK 组入库单类型(与奇门 orderType 枚举中 method=RK 的类型完全一致) */
const RK_TYPES = [ 'B2BRK', 'SCRK', 'LYRK', 'CCRK', 'CGRK', 'DBRK', 'QTRK' ];
/**
* 构造 storage.entry.cancel 共享实现测试桩。
* @param {Object} options 桩配置。
* @param {Object|null} [options.order] 入库单桩(null 表示查询不到)。
* @param {Object} [options.orderMap] 按 id 映射的入库单桩(批量场景)。
* @param {Array<Object>} [options.items] 入库单明细。
* @param {Object} [options.qimenEntrySyncResult] qimenEntrySync 返回结果。
* @param {Object} [options.rollbackResult] rollbackEntryOrderBindings 返回结果。
* @param {Object} [options.user] ctx.user 桩(缺省为测试仓管)。
* @return {Object} service / calls。
*/
function createEntryCancelHarness(options = {}) {
const calls = {
findOne: [],
update: [],
findAllItems: [],
qimenEntrySync: [],
rollbackBindings: [],
createOperationLog: [],
};
const makeOrder = overrides => ({
id: 1,
entry_order_code: 'RK-001',
order_status: 'CREATED',
sync_status: null,
source_type: 'SYSTEM',
warehouse_id: 100000,
store_id: 1000000,
...overrides,
async update(values) {
calls.update.push({ values, order: this });
return this;
},
});
const defaultOrder = options.order === null ? null : makeOrder(options.order || {});
// 批量场景:按 id 映射的入库单桩(null 表示查询不到)
const orderMap = options.orderMap
? Object.fromEntries(
Object.entries(options.orderMap).map(([ orderId, stub ]) => [
orderId,
stub === null || stub === undefined ? null : makeOrder(stub),
])
)
: null;
const ctx = {
app: { config: {} },
logger: { info() {}, warn() {}, error() {}, debug() {} },
user: options.user === undefined
? { store_id: 100000, employees_id: 9, employees_name: '测试仓管' }
: options.user,
model: {
EntryOrder: {
async findOne(query) {
calls.findOne.push(query);
const whereId = query && query.where ? query.where.id : undefined;
if (orderMap && whereId !== undefined && whereId !== null) {
return orderMap[whereId] === undefined ? null : orderMap[whereId];
}
return defaultOrder;
},
},
EntryItems: {
async findAll(query) {
calls.findAllItems.push(query);
return options.items === undefined ? [] : options.items;
},
},
},
service: {
systems: {
inboundDirectLog: {
async qimenEntrySync(params) {
calls.qimenEntrySync.push(params);
return options.qimenEntrySyncResult || { success: true, message: 'ok' };
},
},
receivingEntryMatch: {
async rollbackEntryOrderBindings(params) {
calls.rollbackBindings.push(params);
return options.rollbackResult || { rolled_back: [] };
},
},
operationLog: {
async createOperationLog(params) {
calls.createOperationLog.push(params);
return {};
},
},
},
},
};
const service = new StorageEntryService(ctx);
return { service, calls };
}
/**
* 构造奇门 order 服务测试桩(提供 storage.entry.cancel 与 stockoutOrder.cancel 委托桩)。
* @param {Object} options 桩配置。
* @return {Object} service / calls / stockoutCalls。
*/
function createQimenOrderHarness(options = {}) {
const calls = [];
const stockoutCalls = [];
const ctx = {
app: { config: {} },
logger: { info() {}, warn() {}, error() {}, debug() {} },
service: {
systems: {
storage: {
entry: {
async cancel(data, opts) {
calls.push({ data, opts });
return options.entryCancelResult || { code: 200, message: '作废成功', data: { ids: [ 1 ] } };
},
},
},
stockoutOrder: {
async cancel(data, opts) {
stockoutCalls.push({ data, opts });
return { flag: 'success', code: 1, message: '取消出库单成功' };
},
},
},
},
model: {
// RK 取消不得再直接访问 EntryOrder 模型(旧实现才会命中此处)
EntryOrder: {
async findOne() {
throw new Error('RK 取消不应直接访问 EntryOrder 模型');
},
},
},
};
const service = new QimenOrderService(ctx);
service.setInfo(1000000, 100000, 'app-key', 'customer-id', 'warehouse-code');
return { service, calls, stockoutCalls };
}
/**
* 构造 openapi order 服务测试桩(提供 storage.entry.cancel 与 stockoutOrder.cancel 委托桩)。
* @param {Object} options 桩配置。
* @return {Object} service / calls / stockoutCalls。
*/
function createOpenapiOrderHarness(options = {}) {
const calls = [];
const stockoutCalls = [];
const ctx = {
app: { config: {} },
logger: { info() {}, warn() {}, error() {}, debug() {} },
service: {
systems: {
storage: {
entry: {
async cancel(data, opts) {
calls.push({ data, opts });
return options.entryCancelResult || { code: 200, message: '作废成功', data: { ids: [ 1 ] } };
},
},
},
stockoutOrder: {
async cancel(data, opts) {
stockoutCalls.push({ data, opts });
return { flag: 'success', code: 1, message: '取消出库单成功' };
},
},
},
},
model: options.model || {
// RK / CK 取消不应访问 delivery 模型
OrderDeliveryFactory: {
async getCurrentModel() {
throw new Error('RK/CK 取消不应访问 delivery 模型');
},
},
},
};
const service = new OpenapiOrderService(ctx);
service.setInfo(1000000, 100000, 'APP-KEY', null, '100000');
return { service, calls, stockoutCalls };
}
describe('test/app/service/entry_order.cancel.test.js', () => {
describe('systems.storage.entry.cancel 系统方法入口(不传 options,回归)', () => {
it('{ id } 取消成功:置 CANCELLED、回退收货单占用、写操作日志,非 QM 不回传', async () => {
const { service, calls } = createEntryCancelHarness();
const result = await service.cancel({ id: 1 });
assert.equal(result.code, 200);
assert.equal(result.message, '作废成功');
assert.deepEqual(result.data, { ids: [ 1 ] });
assert.equal(calls.findOne.length, 1);
assert.deepEqual(calls.findOne[0].where, {
id: 1,
warehouse_id: 100000,
is_enabled: 1,
deleted_at: null,
});
assert.equal(calls.update.length, 1);
assert.equal(calls.update[0].values.order_status, 'CANCELLED');
assert.equal(calls.rollbackBindings.length, 1);
assert.equal(calls.rollbackBindings[0].entryOrderId, 1);
assert.equal(calls.qimenEntrySync.length, 0);
assert.equal(calls.createOperationLog.length, 1);
assert.equal(calls.createOperationLog[0].businessType, 'entry_order');
assert.equal(calls.createOperationLog[0].operationCode, 'ENTRY_ORDER_CANCEL');
assert.equal(calls.createOperationLog[0].operator.id, 9);
assert.equal(calls.createOperationLog[0].operator.name, '测试仓管');
assert.equal(calls.createOperationLog[0].extras.message, '入库单已取消');
});
it('{ id } 未找到 → 入库单不存在或无权访问', async () => {
const { service, calls } = createEntryCancelHarness({ order: null });
const result = await service.cancel({ id: 999 });
assert.equal(result.code, 404);
assert.equal(result.message, '入库单不存在或无权访问');
assert.equal(result.data, null);
assert.equal(calls.update.length, 0);
});
it('COMPLETED 守卫拦截,不写库', async () => {
const { service, calls } = createEntryCancelHarness({
order: { order_status: 'COMPLETED' },
});
const result = await service.cancel({ id: 1 });
assert.equal(result.code, 400);
assert.equal(result.message, '已完成入库单不允许作废');
assert.equal(calls.update.length, 0);
assert.equal(calls.qimenEntrySync.length, 0);
});
it('sync_status=SUCCESS 守卫拦截,不写库', async () => {
const { service, calls } = createEntryCancelHarness({
order: { sync_status: 'SUCCESS' },
});
const result = await service.cancel({ id: 1 });
assert.equal(result.code, 400);
assert.equal(result.message, '入库单已完成回传,不可取消');
assert.equal(calls.update.length, 0);
});
it('已 CANCELLED 非幂等返回「入库单已作废」', async () => {
const { service, calls } = createEntryCancelHarness({
order: { order_status: 'CANCELLED' },
});
const result = await service.cancel({ id: 1 });
assert.equal(result.code, 400);
assert.equal(result.message, '入库单已作废');
assert.equal(calls.update.length, 0);
});
it('{ ids } 批量作废:逐单处理并返回 ids 列表', async () => {
const { service, calls } = createEntryCancelHarness({
orderMap: {
1: {
id: 1,
entry_order_code: 'RK-1',
order_status: 'CREATED',
sync_status: null,
source_type: 'SYSTEM',
warehouse_id: 100000,
store_id: 1000000,
},
2: {
id: 2,
entry_order_code: 'RK-2',
order_status: 'CREATED',
sync_status: null,
source_type: 'SYSTEM',
warehouse_id: 100000,
store_id: 1000000,
},
},
});
const result = await service.cancel({ ids: [ 1, 2 ] });
assert.equal(result.code, 200);
assert.deepEqual(result.data, { ids: [ 1, 2 ] });
assert.equal(calls.update.length, 2);
assert.equal(calls.update[0].values.order_status, 'CANCELLED');
assert.equal(calls.update[1].values.order_status, 'CANCELLED');
assert.equal(calls.rollbackBindings.length, 2);
assert.equal(calls.createOperationLog.length, 2);
});
it('QM 来源不传 options:发送取消同步(actualQty 全 0)', async () => {
const { service, calls } = createEntryCancelHarness({
order: { source_type: 'QM' },
items: [
{ item_code: 'A', item_id: '11', count: 5, inventory_type: 'ZP', owner_code: 'OC1' },
],
});
const result = await service.cancel({ id: 1 });
assert.equal(result.code, 200);
assert.equal(calls.qimenEntrySync.length, 1);
const syncParams = calls.qimenEntrySync[0];
assert.equal(syncParams.remark, '入库单取消');
assert.equal(syncParams.operator.id, 9);
assert.equal(syncParams.operator.name, '测试仓管');
assert.equal(typeof syncParams.outBizCode, 'string');
assert.equal(syncParams.outBizCode.startsWith('CANCEL_'), true);
assert.equal(syncParams.orderLines.length, 1);
assert.equal(syncParams.orderLines[0].actualQty, 0);
assert.equal(syncParams.orderLines[0].planQty, 5);
assert.equal(calls.update.length, 1);
});
it('QM 取消同步失败 → 500 取消失败,不写库', async () => {
const { service, calls } = createEntryCancelHarness({
order: { source_type: 'QM' },
items: [{ item_code: 'A', item_id: '11', count: 5 }],
qimenEntrySyncResult: { success: false, message: '奇门同步失败' },
});
const result = await service.cancel({ id: 1 });
assert.equal(result.code, 500);
assert.equal(result.message, '取消失败: 奇门同步失败');
assert.equal(calls.update.length, 0);
});
it('缺 id/ids → id 或 ids 必填', async () => {
const { service, calls } = createEntryCancelHarness();
const result = await service.cancel({});
assert.equal(result.code, 400);
assert.equal(result.message, 'id 或 ids 必填');
assert.equal(calls.findOne.length, 0);
});
});
describe('systems.storage.entry.cancel 外部渠道(options 扩展)', () => {
it('entryOrderCode 定位成功:where 带 is_enabled/deleted_at/warehouse_id/store_id', async () => {
const { service, calls } = createEntryCancelHarness();
const result = await service.cancel(
{ entryOrderCode: 'RK-001' },
{
storeId: 1000000,
warehouseId: 100000,
operatorLabel: 'openapi:APP-KEY',
skipExternalSync: true,
idempotent: true,
notFoundMessage: '未找到对应的入库单',
}
);
assert.equal(result.code, 200);
assert.deepEqual(result.data, { ids: [ 1 ] });
assert.equal(calls.findOne.length, 1);
assert.deepEqual(calls.findOne[0].where, {
entry_order_code: 'RK-001',
warehouse_id: 100000,
is_enabled: 1,
deleted_at: null,
store_id: 1000000,
});
});
it('entry_order_code 别名兼容定位', async () => {
const { service, calls } = createEntryCancelHarness();
const result = await service.cancel(
{ entry_order_code: 'RK-001' },
{ warehouseId: 100000, skipExternalSync: true }
);
assert.equal(result.code, 200);
assert.equal(calls.findOne[0].where.entry_order_code, 'RK-001');
});
it('storeId 为空不参与定位条件', async () => {
const { service, calls } = createEntryCancelHarness();
await service.cancel(
{ entryOrderCode: 'RK-001' },
{ storeId: null, warehouseId: 100000, skipExternalSync: true }
);
assert.deepEqual(calls.findOne[0].where, {
entry_order_code: 'RK-001',
warehouse_id: 100000,
is_enabled: 1,
deleted_at: null,
});
});
it('未找到 → notFoundMessage 文案', async () => {
const { service } = createEntryCancelHarness({ order: null });
const result = await service.cancel(
{ entryOrderCode: 'RK-NOT-FOUND' },
{ warehouseId: 100000, notFoundMessage: '未找到对应的入库单' }
);
assert.equal(result.code, 404);
assert.equal(result.message, '未找到对应的入库单');
});
it('幂等:已 CANCELLED 外部渠道返回成功且不重复写库', async () => {
const { service, calls } = createEntryCancelHarness({
order: { order_status: 'CANCELLED' },
});
const result = await service.cancel(
{ entryOrderCode: 'RK-001' },
{ warehouseId: 100000, idempotent: true, skipExternalSync: true }
);
assert.equal(result.code, 200);
assert.equal(result.message, '作废成功');
assert.deepEqual(result.data, { ids: [ 1 ] });
assert.equal(calls.update.length, 0);
assert.equal(calls.qimenEntrySync.length, 0);
});
it('幂等:已 CANCELLED 且 sync_status=SUCCESS 仍幂等成功(不触发回传守卫)', async () => {
const { service, calls } = createEntryCancelHarness({
order: { order_status: 'CANCELLED', sync_status: 'SUCCESS' },
});
const result = await service.cancel(
{ entryOrderCode: 'RK-001' },
{ warehouseId: 100000, idempotent: true, skipExternalSync: true }
);
assert.equal(result.code, 200);
assert.equal(calls.update.length, 0);
});
it('skipExternalSync:QM 来源不触发 qimenEntrySync 回传', async () => {
const { service, calls } = createEntryCancelHarness({
order: { source_type: 'QM' },
items: [{ item_code: 'A', item_id: '11', count: 5 }],
});
const result = await service.cancel(
{ entryOrderCode: 'RK-001' },
{ warehouseId: 100000, skipExternalSync: true }
);
assert.equal(result.code, 200);
assert.equal(calls.qimenEntrySync.length, 0);
assert.equal(calls.update.length, 1);
});
it('operatorLabel 覆盖操作日志操作人', async () => {
const { service, calls } = createEntryCancelHarness();
await service.cancel(
{ entryOrderCode: 'RK-001' },
{ warehouseId: 100000, operatorLabel: 'openapi:APP-KEY', skipExternalSync: true }
);
assert.equal(calls.createOperationLog.length, 1);
assert.equal(calls.createOperationLog[0].operator.id, null);
assert.equal(calls.createOperationLog[0].operator.name, 'openapi:APP-KEY');
});
it('COMPLETED / sync_status=SUCCESS 守卫在外部门径同样拦截', async () => {
const completedHarness = createEntryCancelHarness({ order: { order_status: 'COMPLETED' } });
const completedResult = await completedHarness.service.cancel(
{ entryOrderCode: 'RK-001' },
{ warehouseId: 100000, idempotent: true, skipExternalSync: true }
);
assert.equal(completedResult.code, 400);
assert.equal(completedResult.message, '已完成入库单不允许作废');
assert.equal(completedHarness.calls.update.length, 0);
const syncedHarness = createEntryCancelHarness({ order: { sync_status: 'SUCCESS' } });
const syncedResult = await syncedHarness.service.cancel(
{ entryOrderCode: 'RK-001' },
{ warehouseId: 100000, idempotent: true, skipExternalSync: true }
);
assert.equal(syncedResult.code, 400);
assert.equal(syncedResult.message, '入库单已完成回传,不可取消');
assert.equal(syncedHarness.calls.update.length, 0);
});
});
describe('奇门 order.cancel RK 组路由', () => {
for (const rkType of RK_TYPES) {
it(`orderType=${rkType} 路由到入库单作废而非直接改模型`, async () => {
const { service, calls } = createQimenOrderHarness();
const result = await service.cancel({
request: { orderType: rkType, orderCode: 'RK-1' },
});
assert.equal(result.flag, 'success');
assert.equal(result.message, '取消入库单成功');
assert.equal(calls.length, 1);
assert.deepEqual(calls[0].data, { entryOrderCode: 'RK-1' });
assert.equal(calls[0].opts.storeId, 1000000);
assert.equal(calls[0].opts.warehouseId, 100000);
assert.equal(calls[0].opts.operatorLabel, 'qimen:customer-id');
assert.equal(calls[0].opts.skipExternalSync, true);
assert.equal(calls[0].opts.idempotent, true);
assert.equal(calls[0].opts.notFoundMessage, '未找到对应的入库单');
});
}
it('CGRK 复现用例:RK_2 可正常取消', async () => {
const { service, calls } = createQimenOrderHarness();
const result = await service.cancel({
request: { orderType: 'CGRK', orderCode: 'RK_2' },
});
assert.equal(result.flag, 'success');
assert.equal(result.message, '取消入库单成功');
assert.deepEqual(calls[0].data, { entryOrderCode: 'RK_2' });
});
it('缺 orderCode → 入库单号不能为空', async () => {
const { service, calls } = createQimenOrderHarness();
const result = await service.cancel({
request: { orderType: 'CGRK', orderCode: ' ' },
});
assert.equal(result.flag, 'failure');
assert.equal(result.message, '入库单号不能为空');
assert.equal(calls.length, 0);
});
it('未找到 → 未找到对应的入库单', async () => {
const { service } = createQimenOrderHarness({
entryCancelResult: { code: 404, message: '未找到对应的入库单', data: null },
});
const result = await service.cancel({
request: { orderType: 'CGRK', orderCode: 'RK-NOT-FOUND' },
});
assert.equal(result.flag, 'failure');
assert.equal(result.message, '未找到对应的入库单');
});
it('守卫文案原样透出', async () => {
const { service } = createQimenOrderHarness({
entryCancelResult: { code: 400, message: '已完成入库单不允许作废', data: null },
});
const result = await service.cancel({
request: { orderType: 'CGRK', orderCode: 'RK-1' },
});
assert.equal(result.flag, 'failure');
assert.equal(result.message, '已完成入库单不允许作废');
});
it('回传失败文案原样透出', async () => {
const { service } = createQimenOrderHarness({
entryCancelResult: { code: 500, message: '取消失败: 奇门同步失败', data: null },
});
const result = await service.cancel({
request: { orderType: 'CGRK', orderCode: 'RK-1' },
});
assert.equal(result.flag, 'failure');
assert.equal(result.message, '取消失败: 奇门同步失败');
});
it('CK 组(PTCK)仍路由到出库单取消,不受 RK 改动影响', async () => {
const { service, calls, stockoutCalls } = createQimenOrderHarness();
const result = await service.cancel({
request: { orderType: 'PTCK', orderCode: 'SO-CK-001' },
});
assert.equal(result.flag, 'success');
assert.equal(result.message, '取消出库单成功');
assert.equal(calls.length, 0);
assert.equal(stockoutCalls.length, 1);
});
});
describe('openapi order.cancel RK 组路由', () => {
for (const rkType of RK_TYPES) {
it(`orderType=${rkType.toLowerCase()}(大小写归一化)路由到入库单作废`, async () => {
const { service, calls } = createOpenapiOrderHarness();
const result = await service.cancel({
body: { orderType: rkType.toLowerCase(), orderCode: 'RK-1' },
query: {},
});
assert.equal(result.flag, 'success');
assert.equal(result.code, 1);
assert.equal(result.message, '取消入库单成功');
assert.equal(calls.length, 1);
assert.deepEqual(calls[0].data, { entryOrderCode: 'RK-1' });
assert.equal(calls[0].opts.storeId, 1000000);
assert.equal(calls[0].opts.warehouseId, 100000);
assert.equal(calls[0].opts.operatorLabel, 'openapi:APP-KEY');
assert.equal(calls[0].opts.skipExternalSync, true);
assert.equal(calls[0].opts.idempotent, true);
assert.equal(calls[0].opts.notFoundMessage, '未找到对应的入库单');
});
}
it('CGRK 复现用例:RK_2 可正常取消', async () => {
const { service, calls } = createOpenapiOrderHarness();
const result = await service.cancel({
body: { orderType: 'CGRK', orderCode: 'RK_2' },
query: {},
});
assert.equal(result.flag, 'success');
assert.equal(result.message, '取消入库单成功');
assert.deepEqual(calls[0].data, { entryOrderCode: 'RK_2' });
});
it('缺 orderCode → orderCode 参数缺失', async () => {
const { service, calls } = createOpenapiOrderHarness();
const result = await service.cancel({
body: { orderType: 'CGRK', orderCode: ' ' },
query: {},
});
assert.equal(result.flag, 'failure');
assert.equal(result.code, 0);
assert.equal(result.message, 'orderCode 参数缺失');
assert.equal(calls.length, 0);
});
it('未找到 → 未找到对应的入库单', async () => {
const { service } = createOpenapiOrderHarness({
entryCancelResult: { code: 404, message: '未找到对应的入库单', data: null },
});
const result = await service.cancel({
body: { orderType: 'CGRK', orderCode: 'RK-NOT-FOUND' },
query: {},
});
assert.equal(result.flag, 'failure');
assert.equal(result.code, 0);
assert.equal(result.message, '未找到对应的入库单');
});
it('守卫文案原样透出(code=0)', async () => {
const { service } = createOpenapiOrderHarness({
entryCancelResult: { code: 400, message: '入库单已完成回传,不可取消', data: null },
});
const result = await service.cancel({
body: { orderType: 'CGRK', orderCode: 'RK-1' },
query: {},
});
assert.equal(result.flag, 'failure');
assert.equal(result.code, 0);
assert.equal(result.message, '入库单已完成回传,不可取消');
});
it('非支持类型(XTRK)仍返回「暂不支持该订单类型的取消操作」', async () => {
const { service, calls } = createOpenapiOrderHarness();
const result = await service.cancel({
body: { orderType: 'XTRK', orderCode: 'RK-1' },
query: {},
});
assert.equal(result.flag, 'failure');
assert.equal(result.message, '暂不支持该订单类型的取消操作');
assert.equal(calls.length, 0);
});
it('CK 组(PTCK)仍路由到出库单取消,不受 RK 改动影响', async () => {
const { service, calls, stockoutCalls } = createOpenapiOrderHarness();
const result = await service.cancel({
body: { orderType: 'PTCK', orderCode: 'SO-CK-001' },
query: {},
});
assert.equal(result.flag, 'success');
assert.equal(result.message, '取消出库单成功');
assert.equal(calls.length, 0);
assert.equal(stockoutCalls.length, 1);
});
it('ORDER 组(JYCK)仍走 delivery 取消分支,不受 RK 改动影响', async () => {
const modelCalls = { deliveryFindOne: 0 };
const transaction = {
LOCK: { UPDATE: 'UPDATE' },
async commit() {
modelCalls.commit += 1;
},
async rollback() {
modelCalls.rollback += 1;
},
};
const { service, calls, stockoutCalls } = 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);
assert.equal(stockoutCalls.length, 0);
});
});
});