- 背景:order_storage_allocation 构造的 routeContext 不含 appKey, finalizeLocalChannelOrdersInternal 的 if(appKey) 门禁导致 API 同步链路的 deliveryorder.confirm 从未真正发出;订单表 from_key 也兜不住 (normalizeOrderFromKey 仅接受整数,字符串 app_key 被归一化为 null) - order_async.js 新增 resolveOpenApiAppByStoreInternal:口径与入库单 _sendOpenApiCallback 对齐(wms_store_warehouse auth_status=2 → wms_api_app is_enabled=1 且 callback_url 非空) - notifyApiDeliveryOrderConfirmsInternal 逐单解析 appKey:context.appKey 非空优先 (不触发反查),缺失时按 orderRow.store_id 反查并按货主缓存(同批次无 N+1); 解析不到 appKey 的订单 warn 后跳过、不发请求 - 补充回调成功 info 日志(含 appKey) - 文档:methods/openapi_callback.json 1.2.0 → 1.3.0、变更记录 methods/changes/openapi_callback.json、docs/openapi-callback-events.md、 AI_METHOD_ROUTING.md 同步 - test: order_async.openapi.callback.test.js 覆盖 context.appKey 为空时反查发送
817 lines
25 KiB
JavaScript
817 lines
25 KiB
JavaScript
'use strict';
|
||
|
||
const assert = require('node:assert/strict');
|
||
const OrderAsyncService = require('../../../../app/service/systems/order_async');
|
||
|
||
/**
|
||
* 轮询等待条件成立(fire-and-forget 回调为异步触发)。
|
||
*
|
||
* @param {Function} predicate 条件函数。
|
||
* @param {number} [timeoutMs] 超时时间(毫秒)。
|
||
* @return {Promise<void>} 条件成立或超时后返回。
|
||
*/
|
||
async function waitFor(predicate, timeoutMs = 500) {
|
||
const startAt = Date.now();
|
||
while (!predicate()) {
|
||
if (Date.now() - startAt > timeoutMs) {
|
||
return;
|
||
}
|
||
|
||
await new Promise(resolve => setTimeout(resolve, 5));
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 构造订单主表记录(raw),字段与 harness 默认单一致,便于多货主场景复用。
|
||
* @param {number} id 订单 ID。
|
||
* @param {number} storeId 货主 ID。
|
||
* @param {string} [deliveryOrderCode] 出库单号,缺省自动生成。
|
||
* @return {Object} 订单主表记录。
|
||
*/
|
||
function makeOrderRow(id, storeId, deliveryOrderCode) {
|
||
return {
|
||
id,
|
||
warehouse_id: 100000,
|
||
store_id: storeId,
|
||
delivery_order_code: deliveryOrderCode || `DO-${id}`,
|
||
warehouse_code: 'WH-100',
|
||
order_type: 'JYCK',
|
||
logistics_code: 'YTO',
|
||
logistics_name: '圆通速递',
|
||
express_code: '',
|
||
name: '测试客户',
|
||
mobile: '13800000000',
|
||
source_order_codes: `SO-${id}`,
|
||
sync_status: 'pending',
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 构造订单明细记录(raw)。
|
||
* @param {number} id 明细 ID。
|
||
* @param {number} orderId 所属订单 ID。
|
||
* @param {string} [itemCode] 商品编码,缺省自动生成。
|
||
* @return {Object} 订单明细记录。
|
||
*/
|
||
function makeOrderItem(id, orderId, itemCode) {
|
||
return {
|
||
id,
|
||
order_id: orderId,
|
||
order_line_no: '1',
|
||
source_order_code: `SRC-${orderId}`,
|
||
owner_code: `OWNER-${orderId}`,
|
||
item_code: itemCode || `SKU-${orderId}`,
|
||
item_id: String(id),
|
||
item_name: `测试商品${orderId}`,
|
||
plan_qty: 1,
|
||
actual_qty: 1,
|
||
inventory_type: 'ZP',
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 创建订单异步服务测试桩(覆盖 OpenAPI 回调与 notice 通道断言)。
|
||
* @param {Object} [options] 可选配置。
|
||
* @param {Array} [options.orderRows] 订单主表记录(raw)。
|
||
* @param {Array} [options.orderItems] 订单明细记录(raw)。
|
||
* @param {Array} [options.orderExpressRows] 运单号记录(raw)。
|
||
* @param {Array} [options.storeWarehouseRows] 货主-仓库授权关系记录(raw)。
|
||
* @param {Array} [options.apiAppRows] ApiApp 配置记录(raw)。
|
||
* @param {Object} [options.stockoutOrder] 出库单主表记录(raw)。
|
||
* @param {Function} [options.onSendByAppKey] OpenAPI 回调桩实现。
|
||
* @param {Function} [options.onOutbound] 库存扣减桩实现(可模拟失败订单)。
|
||
* @param {boolean} [options.omitNoticeService] 是否省略 notice 服务。
|
||
* @return {Object} 服务实例与各调用记录。
|
||
*/
|
||
function createHarness(options = {}) {
|
||
const callbackCalls = [];
|
||
const noticeCalls = [];
|
||
const outboundCalls = [];
|
||
const transactionCalls = [];
|
||
const stockoutUpdates = [];
|
||
const orderUpdates = [];
|
||
const storeWarehouseCalls = [];
|
||
const apiAppCalls = [];
|
||
const warnLogs = [];
|
||
const infoLogs = [];
|
||
|
||
const orderRows = Array.isArray(options.orderRows)
|
||
? options.orderRows.map(item => ({ ...item }))
|
||
: [
|
||
{
|
||
id: 1,
|
||
warehouse_id: 100000,
|
||
store_id: 1000000,
|
||
delivery_order_code: 'DO-1001',
|
||
warehouse_code: 'WH-100',
|
||
order_type: 'JYCK',
|
||
logistics_code: 'YTO',
|
||
logistics_name: '圆通速递',
|
||
express_code: '',
|
||
name: '测试客户',
|
||
mobile: '13800000000',
|
||
source_order_codes: 'SO-1001',
|
||
sync_status: 'pending',
|
||
},
|
||
];
|
||
const orderItems = Array.isArray(options.orderItems)
|
||
? options.orderItems.map(item => ({ ...item }))
|
||
: [
|
||
{
|
||
id: 101,
|
||
order_id: 1,
|
||
order_line_no: '1',
|
||
source_order_code: 'SRC-1',
|
||
owner_code: 'OWNER-001',
|
||
item_code: 'SKU-1',
|
||
item_id: '1001',
|
||
item_name: '测试商品1',
|
||
plan_qty: 2,
|
||
actual_qty: 2,
|
||
inventory_type: 'ZP',
|
||
},
|
||
];
|
||
const orderExpressRows = Array.isArray(options.orderExpressRows)
|
||
? options.orderExpressRows
|
||
: [
|
||
{
|
||
order_id: 1,
|
||
business_key: 9001,
|
||
waybill_code: 'WB-1001',
|
||
},
|
||
];
|
||
const storeWarehouseRows = Array.isArray(options.storeWarehouseRows)
|
||
? options.storeWarehouseRows
|
||
: [
|
||
{
|
||
id: 20001,
|
||
store_id: 1000000,
|
||
warehouse_id: 100000,
|
||
auth_status: 2,
|
||
},
|
||
];
|
||
const apiAppRows = Array.isArray(options.apiAppRows)
|
||
? options.apiAppRows
|
||
: [
|
||
{
|
||
contract_id: 20001,
|
||
is_enabled: 1,
|
||
callback_url: 'https://example.com/callback',
|
||
self_app_key: 'WMSD08A0001',
|
||
self_app_secret: 'SECRET-1',
|
||
},
|
||
];
|
||
|
||
const ctx = {
|
||
app: {
|
||
Sequelize: {
|
||
Op: {
|
||
in: Symbol('in'),
|
||
ne: Symbol('ne'),
|
||
and: Symbol('and'),
|
||
},
|
||
},
|
||
formatDate() {
|
||
return '2026-09-12 10:00:00';
|
||
},
|
||
},
|
||
model: {
|
||
async transaction(callback) {
|
||
const transaction = {
|
||
id: `tx-${transactionCalls.length + 1}`,
|
||
LOCK: { UPDATE: Symbol('UPDATE') },
|
||
};
|
||
transactionCalls.push({ transaction });
|
||
return await callback(transaction);
|
||
},
|
||
OrderDeliveryFactory: {
|
||
async getCurrentModel() {
|
||
return {
|
||
async findAll(query = {}) {
|
||
const inIds = query.where && query.where.id && query.where.id[ctx.app.Sequelize.Op.in];
|
||
if (!Array.isArray(inIds)) {
|
||
return orderRows;
|
||
}
|
||
|
||
const normalizedIds = inIds.map(item => Number(item));
|
||
return orderRows.filter(row => normalizedIds.includes(Number(row.id)));
|
||
},
|
||
async findOne(query = {}) {
|
||
const where = query.where || {};
|
||
const targetId = Number(where.id);
|
||
const targetWarehouseId = Number(where.warehouse_id);
|
||
return orderRows.find(row => Number(row.id) === targetId && Number(row.warehouse_id) === targetWarehouseId) || null;
|
||
},
|
||
async update(values, updateOptions) {
|
||
orderUpdates.push({ values, options: updateOptions });
|
||
return [ 1 ];
|
||
},
|
||
};
|
||
},
|
||
},
|
||
OrderItemsFactory: {
|
||
async getCurrentModel() {
|
||
return {
|
||
async findAll(query = {}) {
|
||
const inIds = query.where && query.where.order_id && query.where.order_id[ctx.app.Sequelize.Op.in];
|
||
if (Array.isArray(inIds)) {
|
||
const normalizedIds = inIds.map(item => Number(item));
|
||
return orderItems.filter(item => normalizedIds.includes(Number(item.order_id)));
|
||
}
|
||
|
||
const singleOrderId = query.where && query.where.order_id;
|
||
if (singleOrderId !== undefined) {
|
||
return orderItems.filter(item => Number(item.order_id) === Number(singleOrderId));
|
||
}
|
||
|
||
return orderItems;
|
||
},
|
||
};
|
||
},
|
||
},
|
||
OrderExpress: {
|
||
async findAll(query = {}) {
|
||
const inIds = query.where && query.where.order_id && query.where.order_id[ctx.app.Sequelize.Op.in];
|
||
if (!Array.isArray(inIds)) {
|
||
return orderExpressRows;
|
||
}
|
||
|
||
const normalizedIds = inIds.map(item => Number(item));
|
||
return orderExpressRows.filter(item => normalizedIds.includes(Number(item.order_id)));
|
||
},
|
||
},
|
||
StoreWarehouse: {
|
||
async findOne(query = {}) {
|
||
storeWarehouseCalls.push(query);
|
||
const where = query.where || {};
|
||
return storeWarehouseRows.find(row => Number(row.store_id) === Number(where.store_id)
|
||
&& Number(row.warehouse_id) === Number(where.warehouse_id)
|
||
&& Number(row.auth_status) === Number(where.auth_status)) || null;
|
||
},
|
||
},
|
||
ApiApp: {
|
||
async findOne(query = {}) {
|
||
apiAppCalls.push(query);
|
||
const where = query.where || {};
|
||
return apiAppRows.find(row => Number(row.contract_id) === Number(where.contract_id)
|
||
&& Number(row.is_enabled) === Number(where.is_enabled)
|
||
&& row.callback_url !== null
|
||
&& row.callback_url !== undefined
|
||
&& String(row.callback_url).trim() !== '') || null;
|
||
},
|
||
},
|
||
OrderStockout: {
|
||
async findOne() {
|
||
return options.stockoutOrder || {
|
||
id: 5001,
|
||
stockout_order_code: 'SO-1001',
|
||
warehouse_id: 100000,
|
||
store_id: 1000000,
|
||
source_type: 'API',
|
||
sync_status: 'PENDING',
|
||
express_code: '',
|
||
express_name: '',
|
||
total_order_lines: 1,
|
||
order_type: 'PTCK',
|
||
qimen_owner_code: 'OWNER-001',
|
||
qimen_warehouse_code: 'WH-100',
|
||
};
|
||
},
|
||
async update(values, updateOptions) {
|
||
stockoutUpdates.push({ values, options: updateOptions });
|
||
return [ 1 ];
|
||
},
|
||
},
|
||
OrderStockoutItems: {
|
||
async findAll() {
|
||
return [
|
||
{
|
||
id: 1,
|
||
order_id: 5001,
|
||
order_line_no: '1',
|
||
owner_code: 'OWNER-001',
|
||
item_code: 'SKU-1',
|
||
item_id: 1001,
|
||
item_name: '测试商品1',
|
||
plan_qty: 2,
|
||
actual_qty: 2,
|
||
inventory_type: 'ZP',
|
||
},
|
||
];
|
||
},
|
||
},
|
||
},
|
||
user: {
|
||
store_id: 1000000,
|
||
},
|
||
service: {
|
||
openapi: {
|
||
callback: {
|
||
async sendByAppKey(callOptions) {
|
||
callbackCalls.push(callOptions);
|
||
if (typeof options.onSendByAppKey === 'function') {
|
||
return await options.onSendByAppKey(callOptions);
|
||
}
|
||
|
||
return { success: true };
|
||
},
|
||
},
|
||
},
|
||
systems: {
|
||
stockStore: {
|
||
async outbound(itemId, quantity, transaction, meta) {
|
||
outboundCalls.push({ itemId, quantity, transaction, meta });
|
||
if (typeof options.onOutbound === 'function') {
|
||
return await options.onOutbound({ itemId, quantity, transaction, meta });
|
||
}
|
||
|
||
return { success: true };
|
||
},
|
||
},
|
||
...(options.omitNoticeService ? {} : {
|
||
notice: {
|
||
async send(payload) {
|
||
noticeCalls.push(payload);
|
||
return { success: true };
|
||
},
|
||
},
|
||
}),
|
||
storeWarehouse: {
|
||
async getContractConfig() {
|
||
return {
|
||
policy_config: {
|
||
notify_manual_sync: 1,
|
||
},
|
||
};
|
||
},
|
||
},
|
||
},
|
||
},
|
||
logger: {
|
||
info(message) {
|
||
infoLogs.push(String(message));
|
||
},
|
||
warn(message) {
|
||
warnLogs.push(String(message));
|
||
},
|
||
error() {},
|
||
},
|
||
};
|
||
|
||
const service = new OrderAsyncService(ctx);
|
||
|
||
return {
|
||
service,
|
||
ctx,
|
||
callbackCalls,
|
||
noticeCalls,
|
||
outboundCalls,
|
||
transactionCalls,
|
||
stockoutUpdates,
|
||
orderUpdates,
|
||
storeWarehouseCalls,
|
||
apiAppCalls,
|
||
warnLogs,
|
||
infoLogs,
|
||
};
|
||
}
|
||
|
||
describe('test/app/service/systems/order_async.openapi.callback.test.js', () => {
|
||
it('API 订单同步完成应逐单发送 deliveryorder.confirm(request 对齐奇门报文,失败单不发送)', async () => {
|
||
const { service, callbackCalls } = createHarness({
|
||
orderRows: [
|
||
{
|
||
id: 1,
|
||
warehouse_id: 100000,
|
||
store_id: 1000000,
|
||
delivery_order_code: 'DO-1001',
|
||
warehouse_code: 'WH-100',
|
||
order_type: 'JYCK',
|
||
logistics_code: 'YTO',
|
||
logistics_name: '圆通速递',
|
||
express_code: '',
|
||
name: '测试客户',
|
||
mobile: '13800000000',
|
||
source_order_codes: 'SO-1001',
|
||
sync_status: 'pending',
|
||
},
|
||
{
|
||
id: 2,
|
||
warehouse_id: 100000,
|
||
store_id: 1000000,
|
||
delivery_order_code: 'DO-1002',
|
||
warehouse_code: 'WH-100',
|
||
order_type: 'JYCK',
|
||
logistics_code: 'YTO',
|
||
logistics_name: '圆通速递',
|
||
express_code: '',
|
||
name: '测试客户2',
|
||
mobile: '13800000001',
|
||
source_order_codes: 'SO-1002',
|
||
sync_status: 'pending',
|
||
},
|
||
{
|
||
id: 3,
|
||
warehouse_id: 100000,
|
||
store_id: 1000000,
|
||
delivery_order_code: 'DO-1003',
|
||
warehouse_code: 'WH-100',
|
||
order_type: 'JYCK',
|
||
logistics_code: 'YTO',
|
||
logistics_name: '圆通速递',
|
||
express_code: '',
|
||
name: '测试客户3',
|
||
mobile: '13800000002',
|
||
source_order_codes: 'SO-1003',
|
||
sync_status: 'pending',
|
||
},
|
||
],
|
||
orderItems: [
|
||
{
|
||
id: 101,
|
||
order_id: 1,
|
||
order_line_no: '1',
|
||
source_order_code: 'SRC-1',
|
||
owner_code: 'OWNER-001',
|
||
item_code: 'SKU-1',
|
||
item_id: '1001',
|
||
item_name: '测试商品1',
|
||
plan_qty: 2,
|
||
actual_qty: 2,
|
||
inventory_type: 'ZP',
|
||
},
|
||
{
|
||
id: 102,
|
||
order_id: 2,
|
||
order_line_no: '1',
|
||
source_order_code: 'SRC-2',
|
||
owner_code: 'OWNER-002',
|
||
item_code: 'SKU-2',
|
||
item_id: '1002',
|
||
item_name: '测试商品2',
|
||
plan_qty: 1,
|
||
actual_qty: 1,
|
||
inventory_type: 'ZP',
|
||
},
|
||
{
|
||
id: 103,
|
||
order_id: 3,
|
||
order_line_no: '1',
|
||
source_order_code: 'SRC-3',
|
||
owner_code: 'OWNER-003',
|
||
item_code: 'SKU-3',
|
||
item_id: '1003',
|
||
item_name: '测试商品3',
|
||
plan_qty: 3,
|
||
actual_qty: 3,
|
||
inventory_type: 'ZP',
|
||
},
|
||
],
|
||
orderExpressRows: [
|
||
{ order_id: 1, business_key: 9001, waybill_code: 'WB-1001' },
|
||
{ order_id: 2, business_key: 9002, waybill_code: 'WB-1002' },
|
||
{ order_id: 3, business_key: 9003, waybill_code: 'WB-1003' },
|
||
],
|
||
onOutbound({ meta }) {
|
||
if (Number(meta.orderId) === 3) {
|
||
return { success: false, error: '库存不足' };
|
||
}
|
||
|
||
return { success: true };
|
||
},
|
||
});
|
||
|
||
const result = await service.syncApiOrders({
|
||
create_channel: 'API',
|
||
order_ids: [ 1, 2, 3 ],
|
||
order_count: 3,
|
||
orders: [{ id: 1 }, { id: 2 }, { id: 3 }],
|
||
}, {
|
||
warehouseId: 100000,
|
||
appKey: 'APP-KEY-8',
|
||
});
|
||
|
||
assert.equal(result.success_count, 2);
|
||
assert.equal(result.failed_count, 1);
|
||
|
||
// fire-and-forget 逐单回调:成功 2 单各发送一次,失败单不发送
|
||
await waitFor(() => callbackCalls.length === 2);
|
||
|
||
assert.equal(callbackCalls.length, 2);
|
||
const sentCodes = callbackCalls.map(call => call.request.deliveryOrder.deliveryOrderCode).sort();
|
||
assert.deepEqual(sentCodes, [ 'DO-1001', 'DO-1002' ]);
|
||
|
||
for (const call of callbackCalls) {
|
||
assert.equal(call.event, 'deliveryorder.confirm');
|
||
assert.equal(call.appKey, 'APP-KEY-8');
|
||
assert.equal(call.data, undefined);
|
||
assert.equal(call.metadata, undefined);
|
||
assert.ok(call.request.deliveryOrder);
|
||
assert.ok(call.request.packages);
|
||
assert.ok(Array.isArray(call.request.orderLines));
|
||
assert.equal(call.request.deliveryOrder.status, 'DELIVERED');
|
||
assert.equal(call.request.deliveryOrder.orderType, 'JYCK');
|
||
// 请求报文不含 event / data / metadata 顶层键
|
||
assert.equal(call.request.event, undefined);
|
||
assert.equal(call.request.data, undefined);
|
||
assert.equal(call.request.metadata, undefined);
|
||
}
|
||
|
||
const firstCall = callbackCalls.find(call => call.request.deliveryOrder.deliveryOrderCode === 'DO-1001');
|
||
assert.equal(firstCall.request.orderLines[0].itemCode, 'SKU-1');
|
||
assert.equal(firstCall.request.packages.package[0].expressCode, 'WB-1001');
|
||
});
|
||
|
||
it('API 订单同步成功 1 单时仍逐单发送(event 与 appKey 正确)', async () => {
|
||
const { service, callbackCalls } = createHarness();
|
||
|
||
const result = await service.syncApiOrders({
|
||
create_channel: 'API',
|
||
order_ids: [ 1 ],
|
||
order_count: 1,
|
||
orders: [{ id: 1 }],
|
||
}, {
|
||
warehouseId: 100000,
|
||
appKey: 'APP-KEY-8',
|
||
});
|
||
|
||
assert.equal(result.status, 'success');
|
||
assert.equal(result.success_count, 1);
|
||
|
||
await waitFor(() => callbackCalls.length === 1);
|
||
|
||
assert.equal(callbackCalls.length, 1);
|
||
assert.equal(callbackCalls[0].event, 'deliveryorder.confirm');
|
||
assert.equal(callbackCalls[0].appKey, 'APP-KEY-8');
|
||
assert.equal(callbackCalls[0].data, undefined);
|
||
assert.equal(callbackCalls[0].metadata, undefined);
|
||
assert.equal(callbackCalls[0].request.deliveryOrder.deliveryOrderCode, 'DO-1001');
|
||
});
|
||
|
||
it('API 来源出库单回传 method 应为 stockout.confirm(request 为奇门同层级报文)', async () => {
|
||
const { service, callbackCalls } = createHarness();
|
||
|
||
const result = await service.syncStockoutOrders({
|
||
create_channel: 'STOCKOUT',
|
||
order_ids: [ 1 ],
|
||
order_count: 1,
|
||
orders: [{ id: 1 }],
|
||
}, {
|
||
warehouseId: 100000,
|
||
appKey: 'APP-KEY-9',
|
||
});
|
||
|
||
assert.equal(result.status, 'success');
|
||
assert.equal(result.success_count, 1);
|
||
assert.equal(callbackCalls.length, 1);
|
||
assert.equal(callbackCalls[0].event, 'stockout.confirm');
|
||
assert.equal(callbackCalls[0].appKey, 'APP-KEY-9');
|
||
assert.equal(callbackCalls[0].data, undefined);
|
||
assert.equal(callbackCalls[0].metadata, undefined);
|
||
|
||
const request = callbackCalls[0].request;
|
||
assert.ok(request.deliveryOrder);
|
||
assert.ok(request.packages);
|
||
assert.ok(Array.isArray(request.orderLines));
|
||
assert.equal(request.deliveryOrder.deliveryOrderCode, 'SO-1001');
|
||
assert.equal(request.orderLines.length, 1);
|
||
// 不再包含 stockoutOrderCode / status 外层薄包装,也不含 event / data / metadata 顶层键
|
||
assert.equal(request.stockoutOrderCode, undefined);
|
||
assert.equal(request.status, undefined);
|
||
assert.equal(request.event, undefined);
|
||
assert.equal(request.data, undefined);
|
||
assert.equal(request.metadata, undefined);
|
||
});
|
||
|
||
it('手工同步 notice 通道事件名 order_sync_completed 未被误改', async () => {
|
||
const { service, noticeCalls } = createHarness();
|
||
|
||
const result = await service.syncManualOrders({
|
||
create_channel: 'MANUAL',
|
||
order_ids: [ 1 ],
|
||
order_count: 1,
|
||
orders: [{ id: 1 }],
|
||
}, {
|
||
warehouseId: 100000,
|
||
});
|
||
|
||
assert.equal(result.status, 'success');
|
||
assert.equal(noticeCalls.length, 1);
|
||
assert.equal(noticeCalls[0].event, 'order_sync_completed');
|
||
assert.equal(noticeCalls[0].businessName, 'order');
|
||
});
|
||
|
||
it('context.appKey 为空时按订单货主合约反查 ApiApp 并发送回调(appKey=self_app_key)', async () => {
|
||
const { service, callbackCalls, storeWarehouseCalls, apiAppCalls } = createHarness();
|
||
|
||
const result = await service.syncApiOrders({
|
||
create_channel: 'API',
|
||
order_ids: [ 1 ],
|
||
order_count: 1,
|
||
orders: [{ id: 1 }],
|
||
}, {
|
||
warehouseId: 100000,
|
||
});
|
||
|
||
assert.equal(result.status, 'success');
|
||
assert.equal(result.success_count, 1);
|
||
|
||
await waitFor(() => callbackCalls.length === 1);
|
||
|
||
assert.equal(callbackCalls.length, 1);
|
||
assert.equal(callbackCalls[0].event, 'deliveryorder.confirm');
|
||
assert.equal(callbackCalls[0].appKey, 'WMSD08A0001');
|
||
assert.equal(storeWarehouseCalls.length, 1);
|
||
assert.equal(apiAppCalls.length, 1);
|
||
});
|
||
|
||
it('context.appKey 非空时优先使用,且不触发合约反查', async () => {
|
||
const { service, callbackCalls, storeWarehouseCalls, apiAppCalls } = createHarness();
|
||
|
||
const result = await service.syncApiOrders({
|
||
create_channel: 'API',
|
||
order_ids: [ 1 ],
|
||
order_count: 1,
|
||
orders: [{ id: 1 }],
|
||
}, {
|
||
warehouseId: 100000,
|
||
appKey: 'APP-KEY-8',
|
||
});
|
||
|
||
assert.equal(result.status, 'success');
|
||
|
||
await waitFor(() => callbackCalls.length === 1);
|
||
|
||
assert.equal(callbackCalls.length, 1);
|
||
assert.equal(callbackCalls[0].appKey, 'APP-KEY-8');
|
||
// 未触发货主合约反查
|
||
assert.equal(storeWarehouseCalls.length, 0);
|
||
assert.equal(apiAppCalls.length, 0);
|
||
});
|
||
|
||
it('合约下无授权关系时跳过回调并记录 warn', async () => {
|
||
const { service, callbackCalls, storeWarehouseCalls, apiAppCalls, warnLogs } = createHarness({
|
||
storeWarehouseRows: [],
|
||
});
|
||
|
||
const result = await service.syncApiOrders({
|
||
create_channel: 'API',
|
||
order_ids: [ 1 ],
|
||
order_count: 1,
|
||
orders: [{ id: 1 }],
|
||
}, {
|
||
warehouseId: 100000,
|
||
});
|
||
|
||
assert.equal(result.status, 'success');
|
||
|
||
await waitFor(() => warnLogs.some(log => log.includes('未找到授权关系')));
|
||
|
||
assert.equal(callbackCalls.length, 0);
|
||
assert.equal(storeWarehouseCalls.length, 1);
|
||
assert.equal(apiAppCalls.length, 0);
|
||
});
|
||
|
||
it('合约下 ApiApp 停用或 callback_url 为空时跳过回调并记录 warn', async () => {
|
||
const cases = [
|
||
{
|
||
name: 'is_enabled=0',
|
||
apiAppRows: [
|
||
{
|
||
contract_id: 20001,
|
||
is_enabled: 0,
|
||
callback_url: 'https://example.com/callback',
|
||
self_app_key: 'WMSD08A0001',
|
||
self_app_secret: 'SECRET-1',
|
||
},
|
||
],
|
||
},
|
||
{
|
||
name: 'callback_url 为空',
|
||
apiAppRows: [
|
||
{
|
||
contract_id: 20001,
|
||
is_enabled: 1,
|
||
callback_url: '',
|
||
self_app_key: 'WMSD08A0001',
|
||
self_app_secret: 'SECRET-1',
|
||
},
|
||
],
|
||
},
|
||
];
|
||
|
||
for (const caseItem of cases) {
|
||
const { service, callbackCalls, storeWarehouseCalls, apiAppCalls, warnLogs } = createHarness({
|
||
apiAppRows: caseItem.apiAppRows,
|
||
});
|
||
|
||
const result = await service.syncApiOrders({
|
||
create_channel: 'API',
|
||
order_ids: [ 1 ],
|
||
order_count: 1,
|
||
orders: [{ id: 1 }],
|
||
}, {
|
||
warehouseId: 100000,
|
||
});
|
||
|
||
assert.equal(result.status, 'success');
|
||
|
||
await waitFor(() => warnLogs.some(log => log.includes('未找到有效ApiApp配置')));
|
||
|
||
assert.equal(callbackCalls.length, 0, `${caseItem.name} 不应发送回调`);
|
||
assert.equal(storeWarehouseCalls.length, 1);
|
||
assert.equal(apiAppCalls.length, 1);
|
||
}
|
||
});
|
||
|
||
it('多货主批次各自按货主反查 appKey,同货主只查一次库', async () => {
|
||
const { service, callbackCalls, storeWarehouseCalls, apiAppCalls } = createHarness({
|
||
orderRows: [
|
||
makeOrderRow(1, 1000000, 'DO-1001'),
|
||
makeOrderRow(2, 1000000, 'DO-1002'),
|
||
makeOrderRow(3, 2000000, 'DO-1003'),
|
||
],
|
||
orderItems: [
|
||
makeOrderItem(101, 1, 'SKU-1'),
|
||
makeOrderItem(102, 2, 'SKU-2'),
|
||
makeOrderItem(103, 3, 'SKU-3'),
|
||
],
|
||
orderExpressRows: [
|
||
{ order_id: 1, business_key: 9001, waybill_code: 'WB-1001' },
|
||
{ order_id: 2, business_key: 9002, waybill_code: 'WB-1002' },
|
||
{ order_id: 3, business_key: 9003, waybill_code: 'WB-1003' },
|
||
],
|
||
storeWarehouseRows: [
|
||
{ id: 20001, store_id: 1000000, warehouse_id: 100000, auth_status: 2 },
|
||
{ id: 20002, store_id: 2000000, warehouse_id: 100000, auth_status: 2 },
|
||
],
|
||
apiAppRows: [
|
||
{
|
||
contract_id: 20001,
|
||
is_enabled: 1,
|
||
callback_url: 'https://example.com/cb1',
|
||
self_app_key: 'WMSD08A0001',
|
||
self_app_secret: 'SECRET-1',
|
||
},
|
||
{
|
||
contract_id: 20002,
|
||
is_enabled: 1,
|
||
callback_url: 'https://example.com/cb2',
|
||
self_app_key: 'WMSD08A0002',
|
||
self_app_secret: 'SECRET-2',
|
||
},
|
||
],
|
||
});
|
||
|
||
const result = await service.syncApiOrders({
|
||
create_channel: 'API',
|
||
order_ids: [ 1, 2, 3 ],
|
||
order_count: 3,
|
||
orders: [{ id: 1 }, { id: 2 }, { id: 3 }],
|
||
}, {
|
||
warehouseId: 100000,
|
||
});
|
||
|
||
assert.equal(result.success_count, 3);
|
||
|
||
await waitFor(() => callbackCalls.length === 3);
|
||
|
||
assert.equal(callbackCalls.length, 3);
|
||
const appKeyByCode = new Map(callbackCalls.map(call => [ call.request.deliveryOrder.deliveryOrderCode, call.appKey ]));
|
||
assert.equal(appKeyByCode.get('DO-1001'), 'WMSD08A0001');
|
||
assert.equal(appKeyByCode.get('DO-1002'), 'WMSD08A0001');
|
||
assert.equal(appKeyByCode.get('DO-1003'), 'WMSD08A0002');
|
||
// 缓存命中:3 单共 2 个货主,StoreWarehouse / ApiApp 各只查询 2 次
|
||
assert.equal(storeWarehouseCalls.length, 2);
|
||
assert.equal(apiAppCalls.length, 2);
|
||
});
|
||
|
||
it('订单缺少货主 store_id 时跳过回调并记录 warn', async () => {
|
||
const { service, callbackCalls, storeWarehouseCalls, apiAppCalls, warnLogs } = createHarness({
|
||
orderRows: [
|
||
makeOrderRow(1, 0, 'DO-1001'),
|
||
],
|
||
orderItems: [
|
||
makeOrderItem(101, 1, 'SKU-1'),
|
||
],
|
||
});
|
||
|
||
const result = await service.syncApiOrders({
|
||
create_channel: 'API',
|
||
order_ids: [ 1 ],
|
||
order_count: 1,
|
||
orders: [{ id: 1 }],
|
||
}, {
|
||
warehouseId: 100000,
|
||
});
|
||
|
||
assert.equal(result.status, 'success');
|
||
|
||
await waitFor(() => warnLogs.some(log => log.includes('订单缺少货主')));
|
||
|
||
assert.equal(callbackCalls.length, 0);
|
||
assert.equal(storeWarehouseCalls.length, 0);
|
||
assert.equal(apiAppCalls.length, 0);
|
||
});
|
||
});
|