WMS_MAIN/test/app/service/systems/order_async.openapi.callback.test.js
liufumingren 2555f3bb4d fix(openapi): deliveryorder.confirm 回调 appKey 按货主合约反查
- 背景: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 为空时反查发送
2026-09-13 15:29:51 +08:00

817 lines
25 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 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);
});
});