WMS_MAIN/test/app/service/systemMethods/storage/stockout.confirm.outbound.test.js
liufumingren 55f766f643 fix(stockout): 出库单确认按来源分流回传,运单号口径收敛为复数
- storage.stockout.confirm 出站回传改为按 source_type 分流(复用 order_async.js 既有分流实现):
  QM→奇门 taobao.qimen.stockout.confirm;API→OpenAPI 回调 stockout.confirm(appKey 按货主合约
  反查 wms_store_warehouse(auth_status=2) + wms_api_app(启用且 callback_url 非空));
  WMS 等内部来源无需外部通知、直接视为成功。修复此前 API 来源出库单被硬编码发往奇门、
  遭「-1 无法匹配货主」拒绝后无法确认(跳过出站同样走失败分支)的问题。
- storage.stockout.confirm 运单号校验与回传改为以复数 waybill_codes 为准(对齐奇门
  packages.package[].expressCode 多运单模型,不使用 deliveryOrder.expressCode);
  单数 waybill_code 已弃用,仅在复数缺失时回退单数兼容存量单;失败文案改为 (waybill_codes)。
- storage.stockout.updateExpress 以 waybill_codes 为准,单数 waybill_code 降级为镜像字段
  (传非空复数时镜像首个、传空数组/null 时同步置 NULL、同时传两列时复数优先);
  仅传单数的旧调用方行为不变。
- app/service/systems/order_async.js 新增 3 个可复用实例方法(buildStockoutConfirmRequest /
  notifyStockoutExternal / resolveOpenApiAppByStore),薄封装既有模块级实现,
  未改动原函数及其既有调用方。
- 新增回归测试:stockout.confirm.outbound.test.js(8 条,覆盖 API/QM/WMS 三路来源、多运单复数
  回传、存量单单数回退)、stockout.updateExpress.test.js(7 条,覆盖复数镜像与兼容行为)。
- 同步 methods/system.json 与 methods/changes/system.json(storage.stockout.confirm /
  storage.stockout.updateExpress)。
2026-09-15 15:40:39 +08:00

337 lines
12 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 StorageStockoutService = require('../../../../../app/service/systemMethods/storage/stockout');
const OrderAsyncService = require('../../../../../app/service/systems/order_async');
/**
* 构造 storage.stockout.confirm 出站分流测试桩。
*
* 覆盖两条真实链路:systemMethods/storage/stockout 与 systems/order_async 共用同一 ctx,
* 便于断言「API 来源走 OpenAPI 回调、QM 来源走奇门、内部来源不发外部请求」。
*
* @param {Object} [options] 可选配置。
* @param {string} [options.sourceType] 出库单来源(API/QM/WMS),默认 API。
* @param {string} [options.waybillCode] 运单号(单号),传 null 模拟未填。
* @param {Array<string>} [options.waybillCodes] 运单号列表。
* @param {string} [options.qimenFlag] 奇门返回 flag,默认 success。
* @param {Object|null} [options.storeWarehouseRow] 货主-仓库授权关系,传 null 模拟无授权。
* @param {Object|null} [options.apiAppRow] ApiApp 配置,传 null 模拟无可用回调配置。
* @param {boolean} [options.callbackSuccess] OpenAPI 回调结果,默认成功。
* @return {Object} 服务实例与各调用记录。
*/
function createHarness(options = {}) {
const callbackCalls = [];
const qimenCalls = [];
const stockoutUpdates = [];
const itemUpdates = [];
const storeWarehouseCalls = [];
const apiAppCalls = [];
const opLogCalls = [];
const lockCalls = [];
const warnLogs = [];
const errorLogs = [];
const order = {
id: 23,
stockout_order_code: 'CK_2',
order_type: 'PTCK',
total_order_lines: 1,
order_status: 'CREATED',
sync_status: 'PENDING',
source_type: options.sourceType === undefined ? 'API' : options.sourceType,
warehouse_id: 100000,
store_id: 1000300,
qimen_owner_code: 'tbyc20260614',
qimen_warehouse_code: '100000',
express_code: 'ZT',
express_name: '自提',
waybill_code: options.waybillCode === undefined ? '5855555555' : options.waybillCode,
waybill_codes: options.waybillCodes === undefined ? [ '5855555555' ] : options.waybillCodes,
canConfirm() {
return this.order_status === 'CREATED' || this.order_status === 'PENDING';
},
};
const items = [
{
id: 14,
order_id: 23,
order_line_no: '1',
owner_code: 'tbyc20260614',
item_code: 'P260911231515227608',
item_id: 9001,
item_name: '测试商品2',
plan_qty: 5,
actual_qty: 0,
inventory_type: 'ZP',
stock_id: 159077,
async update(values) {
itemUpdates.push(values);
Object.assign(this, values);
},
},
];
const ctx = {
app: {
config: {},
formatDate() {
return '2026-09-13 10:00:00';
},
Sequelize: {
Op: {
in: Symbol('in'),
ne: Symbol('ne'),
and: Symbol('and'),
},
},
qimenClient: {
async send(method, ownerCode, requestData, extra) {
qimenCalls.push({ method, ownerCode, requestData, extra });
return {
xmlArray: {
response: options.qimenFlag === 'failure'
? { flag: 'failure', code: '-1', message: '无法匹配货主' }
: { flag: 'success' },
},
};
},
},
},
user: { store_id: 100000 },
model: {
async transaction(callback) {
const transaction = {
commit: async () => {},
rollback: async () => {},
};
if (typeof callback === 'function') {
return await callback(transaction);
}
return transaction;
},
OrderStockout: {
async findByPk() {
return order;
},
async findOne() {
return order;
},
async update(values) {
stockoutUpdates.push(values);
Object.assign(order, values);
return [ 1 ];
},
},
OrderStockoutItems: {
async findAll() {
return items;
},
},
StoreWarehouse: {
async findOne(query) {
storeWarehouseCalls.push(query);
if (options.storeWarehouseRow === null) {
return null;
}
return options.storeWarehouseRow || { id: 20001 };
},
},
ApiApp: {
async findOne(query) {
apiAppCalls.push(query);
if (options.apiAppRow === null) {
return null;
}
return options.apiAppRow || {
self_app_key: 'WMSD08A0001',
self_app_secret: 'SECRET-1',
callback_url: 'https://example.com/callback',
};
},
},
},
service: {
openapi: {
callback: {
async sendByAppKey(callOptions) {
callbackCalls.push(callOptions);
if (options.callbackSuccess === false) {
return { success: false, error: '回调地址不可达' };
}
return { success: true };
},
},
},
systems: {
orderAsync: null,
stockoutOrder: {
async _writeStockoutOperationLog(opOrder, operationCode, message, logOptions) {
opLogCalls.push({ opOrder, operationCode, message, logOptions });
},
async cancel() {
return { flag: 'success', code: 1, message: '取消成功' };
},
},
stockStore: {
async lockItemStorages(stockId, qty, transaction, oversellConfig, meta) {
lockCalls.push({ stockId, qty, transaction, oversellConfig, meta });
return { success: true };
},
},
},
},
logger: {
info() {},
warn(message) {
warnLogs.push(String(message));
},
error(message) {
errorLogs.push(String(message));
},
},
};
// 真实 OrderAsyncService 实例:出站分流逻辑不做桩替换,保证端到端覆盖
ctx.service.systems.orderAsync = new OrderAsyncService(ctx);
return {
order,
service: new StorageStockoutService(ctx),
callbackCalls,
qimenCalls,
stockoutUpdates,
itemUpdates,
storeWarehouseCalls,
apiAppCalls,
opLogCalls,
lockCalls,
warnLogs,
errorLogs,
};
}
describe('test/app/service/systemMethods/storage/stockout.confirm.outbound.test.js', () => {
it('API 来源出库单确认应走 OpenAPI 回调 stockout.confirm,且不调用奇门', async () => {
const harness = createHarness({ sourceType: 'API' });
const result = await harness.service.confirm({ id: 23 });
// 未调用奇门,改为 OpenAPI 回调
assert.equal(harness.qimenCalls.length, 0, 'API 来源不应调用奇门');
assert.equal(harness.callbackCalls.length, 1, 'API 来源应发送 OpenAPI 回调');
assert.equal(harness.callbackCalls[0].event, 'stockout.confirm');
assert.equal(harness.callbackCalls[0].appKey, 'WMSD08A0001');
// 回调报文与奇门同层级,快递/运单号取自重出库单字段
const request = harness.callbackCalls[0].request;
assert.equal(request.deliveryOrder.deliveryOrderCode, 'CK_2');
assert.equal(request.deliveryOrder.orderType, 'PTCK');
assert.equal(request.deliveryOrder.warehouseCode, '100000');
assert.equal(request.packages.package.length, 1);
assert.equal(request.packages.package[0].logisticsCode, 'ZT');
assert.equal(request.packages.package[0].logisticsName, '自提');
assert.equal(request.packages.package[0].expressCode, '5855555555');
assert.equal(request.orderLines[0].ownerCode, 'tbyc20260614');
assert.equal(request.orderLines[0].planQty, 5);
// 回调成功 → 释放锁定并推进 COMPLETED
assert.equal(result.flag, 'success');
assert.equal(harness.order.order_status, 'COMPLETED');
assert.equal(harness.lockCalls.length, 1);
});
it('API 来源但货主无可用 ApiApp 时应失败且不回落奇门', async () => {
const harness = createHarness({ sourceType: 'API', apiAppRow: null });
const result = await harness.service.confirm({ id: 23 });
assert.equal(harness.qimenCalls.length, 0, 'API 来源不应回落奇门');
assert.equal(harness.callbackCalls.length, 0, '无 appKey 时不应发送回调');
assert.equal(result.flag, 'failure');
assert.match(result.message, /缺少 appKey/);
assert.equal(harness.order.order_status, 'CREATED');
assert.equal(harness.order.sync_status, 'FAILED');
});
it('QM 来源出库单确认仍走奇门 stockout.confirm,且不发 OpenAPI 回调', async () => {
const harness = createHarness({ sourceType: 'QM' });
const result = await harness.service.confirm({ id: 23 });
assert.equal(harness.callbackCalls.length, 0, 'QM 来源不应发送 OpenAPI 回调');
assert.equal(harness.qimenCalls.length, 1);
assert.equal(harness.qimenCalls[0].method, 'taobao.qimen.stockout.confirm');
assert.equal(harness.qimenCalls[0].ownerCode, 'tbyc20260614');
assert.equal(result.flag, 'success');
assert.equal(harness.order.order_status, 'COMPLETED');
});
it('内部来源(WMS)出库单确认无需外部通知,直接完成', async () => {
const harness = createHarness({ sourceType: 'WMS' });
const result = await harness.service.confirm({ id: 23 });
assert.equal(harness.qimenCalls.length, 0, '内部来源不应调用奇门');
assert.equal(harness.callbackCalls.length, 0, '内部来源不应发送 OpenAPI 回调');
assert.equal(result.flag, 'success');
assert.equal(harness.order.order_status, 'COMPLETED');
assert.equal(harness.lockCalls.length, 1);
});
it('QM 来源奇门返回失败时应保持 CREATED 并记录 sync_message', async () => {
const harness = createHarness({ sourceType: 'QM', qimenFlag: 'failure' });
const result = await harness.service.confirm({ id: 23 });
assert.equal(result.flag, 'failure');
assert.match(result.message, /无法匹配货主/);
assert.equal(harness.order.order_status, 'CREATED');
assert.equal(harness.order.sync_status, 'FAILED');
assert.match(harness.order.sync_message, /无法匹配货主/);
assert.equal(harness.lockCalls.length, 0, '失败时不应释放库存锁定');
});
it('未填写运单号(复数与单数均为空)时直接拒绝确认', async () => {
const harness = createHarness({ sourceType: 'API', waybillCode: null, waybillCodes: null });
const result = await harness.service.confirm({ id: 23 });
assert.equal(result.flag, 'failure');
assert.match(result.message, /waybill_codes/);
assert.equal(harness.qimenCalls.length, 0);
assert.equal(harness.callbackCalls.length, 0);
});
it('一单多运单:只填复数 waybill_codes 即可确认,回传走 packages.package[]', async () => {
const harness = createHarness({
sourceType: 'API',
waybillCode: null, // 单数已弃用,调用方不再传
waybillCodes: [ 'WB-A', 'WB-B' ],
});
const result = await harness.service.confirm({ id: 23 });
assert.equal(result.flag, 'success');
assert.equal(harness.callbackCalls.length, 1);
// 多运单通过 packages.package[] 承载,不使用 deliveryOrder.expressCode
const pkgs = harness.callbackCalls[0].request.packages.package;
assert.equal(pkgs.length, 2);
assert.deepEqual(pkgs.map(item => item.expressCode), [ 'WB-A', 'WB-B' ]);
assert.equal(harness.callbackCalls[0].request.deliveryOrder.expressCode, undefined);
assert.equal(harness.order.order_status, 'COMPLETED');
});
it('存量单仅有单数 waybill_code 时仍可确认(兼容回退)', async () => {
const harness = createHarness({ sourceType: 'API', waybillCode: 'OLD-WB-1', waybillCodes: null });
const result = await harness.service.confirm({ id: 23 });
assert.equal(result.flag, 'success');
const pkgs = harness.callbackCalls[0].request.packages.package;
assert.deepEqual(pkgs.map(item => item.expressCode), [ 'OLD-WB-1' ]);
});
});