WMS_MAIN/test/app/service/systems/express.test.js
liufumingren dc4894cb6d 1
2026-05-25 17:08:56 +08:00

864 lines
30 KiB
JavaScript

'use strict';
const assert = require('node:assert/strict');
const ExpressService = require('../../../../app/service/systems/express');
const IndexMethodService = require('../../../../app/service/systemMethods/index');
function createExpressServiceHarness(options = {}) {
const calls = {
expressFindAll: 0,
expressSettingFindAll: 0,
expressProductTypeFindAll: 0,
expressProductTypeCreate: 0,
expressProductTypeUpdate: 0,
orderDeliveryFindAll: 0,
getCache: 0,
setCache: 0,
delCache: 0,
};
const expressProductTypeRows = Array.isArray(options.expressProductTypeRows)
? options.expressProductTypeRows.map((item, index) => ({
id: Number(item.id || index + 1),
code: item.code,
name: item.name,
express_code: item.express_code,
}))
: [
{ id: 1, code: 'SF-EXP', name: '顺丰标准', express_code: 'SF' },
{ id: 2, code: 'SF-ECON', name: '顺丰经济', express_code: 'SF' },
];
const orderDeliveryRows = Array.isArray(options.orderDeliveryRows) ? options.orderDeliveryRows : [];
const orderDeliveryModel = {
async findAll(query) {
calls.orderDeliveryFindAll += 1;
calls.orderDeliveryFindAllQuery = query;
return orderDeliveryRows;
},
};
const ctx = {
app: {
Sequelize: {
Op: {
in: 'in',
ne: 'ne',
lt: 'lt',
},
},
async getCacheAsync(cacheKey) {
calls.getCache += 1;
if (typeof options.getCacheAsync === 'function') {
return await options.getCacheAsync(cacheKey);
}
return options.cachedValue === undefined ? null : options.cachedValue;
},
async setCacheAsync(cacheKey, value, ttl) {
calls.setCache += 1;
calls.cachePayload = { cacheKey, value, ttl };
if (typeof options.setCacheAsync === 'function') {
return await options.setCacheAsync(cacheKey, value, ttl);
}
},
async delCacheAsync(cacheKey) {
calls.delCache += 1;
calls.delCacheKey = cacheKey;
if (typeof options.delCacheAsync === 'function') {
return await options.delCacheAsync(cacheKey);
}
},
},
user: options.user || null,
model: {
OrderDeliveryFactory: {
async getCurrentModel() {
return orderDeliveryModel;
},
},
Express: {
async findAll(query) {
calls.expressFindAll += 1;
calls.expressFindAllQuery = query;
return options.rows || [
{ code: 'STO', name: '顺丰' },
{ code: 'TB', name: '淘宝快递' },
];
},
},
ExpressSetting: {
async findAll(query) {
calls.expressSettingFindAll += 1;
calls.expressSettingFindAllQuery = query;
const where = query && query.where ? query.where : {};
let rows = Array.isArray(options.expressSettingRows) ? options.expressSettingRows : [];
if (where.warehouse_id !== undefined) {
rows = rows.filter(item => Number(item.warehouse_id) === Number(where.warehouse_id));
}
if (where.express_code) {
rows = rows.filter(item => String(item.express_code) === String(where.express_code));
}
return rows;
},
},
ExpressProductType: {
async findAll(query) {
calls.expressProductTypeFindAll += 1;
calls.expressProductTypeFindAllQuery = query;
const where = query && query.where ? query.where : null;
let rows = expressProductTypeRows;
if (where && where.express_code) {
rows = rows.filter(item => item.express_code === where.express_code);
}
if (where && where.code && typeof where.code === 'object' && Array.isArray(where.code.in)) {
const codeSet = new Set(where.code.in.map(item => String(item)));
rows = rows.filter(item => codeSet.has(String(item.code)));
}
return rows;
},
async create(values) {
calls.expressProductTypeCreate += 1;
const created = {
id: expressProductTypeRows.length + 1,
...values,
};
expressProductTypeRows.push(created);
return created;
},
async update(values, optionsForUpdate) {
calls.expressProductTypeUpdate += 1;
const where = optionsForUpdate && optionsForUpdate.where ? optionsForUpdate.where : {};
for (const row of expressProductTypeRows) {
if (where.id && Number(row.id) !== Number(where.id)) {
continue;
}
Object.assign(row, values);
}
return [ 1 ];
},
},
},
logger: {
info() {},
warn() {},
error() {},
},
};
return {
ctx,
calls,
};
}
describe('test/app/service/systems/express.test.js', () => {
it('should load express list from database and cache it when cache is empty', async () => {
const { ctx, calls } = createExpressServiceHarness();
const service = new ExpressService(ctx);
const result = await service.getExpressList();
assert.equal(calls.getCache, 1);
assert.equal(calls.expressFindAll, 1);
assert.equal(calls.setCache, 1);
assert.equal(calls.cachePayload.cacheKey, 'express:list');
assert.equal(calls.cachePayload.ttl, 600);
assert.deepEqual(result, [
{ code: 'STO', name: '顺丰', value: 'STO', label: '顺丰', is_system_setting: false, id: null, alias: null },
{ code: 'TB', name: '淘宝快递', value: 'TB', label: '淘宝快递', is_system_setting: false, id: null, alias: null },
]);
});
it('should merge express settings for the current warehouse and keep real express codes', async () => {
const { ctx, calls } = createExpressServiceHarness({
user: {
store_id: 100000,
},
rows: [
{ code: 'SF', name: '顺丰' },
{ code: 'YTO', name: '圆通' },
],
expressSettingRows: [
{ id: 11, code: 'SF-001', name: '顺丰设置', express_code: 'SF', warehouse_id: 100000 },
{ id: 12, code: 'SF-001', name: '圆通设置', express_code: 'YTO', warehouse_id: 100000 },
{ id: 13, code: 'YTO-001', name: '圆通设置', express_code: 'YTO', warehouse_id: 100000 },
],
});
const service = new ExpressService(ctx);
const result = await service.getExpressList();
assert.equal(calls.getCache, 1);
assert.equal(calls.expressFindAll, 1);
assert.equal(calls.expressSettingFindAll, 1);
assert.deepEqual(calls.expressSettingFindAllQuery.where, { warehouse_id: 100000 });
assert.equal(calls.cachePayload.cacheKey, 'express:list:100000');
assert.deepEqual(result, [
{ code: 'SF', name: '顺丰', value: 'SF', label: '顺丰', is_system_setting: false, id: null, alias: null },
{ code: 'YTO', name: '圆通', value: 'YTO', label: '圆通', is_system_setting: false, id: null, alias: null },
{ code: 'SF-001', name: 'SF-001 (顺丰)', value: 'SF-001', label: 'SF-001 (顺丰)', express_code: 'SF', is_system_setting: true, id: 11, alias: '顺丰设置' },
{ code: 'YTO-001', name: 'YTO-001 (圆通)', value: 'YTO-001', label: 'YTO-001 (圆通)', express_code: 'YTO', is_system_setting: true, id: 13, alias: '圆通设置' },
]);
});
it('should keep original express rows when a setting uses the same code', async () => {
const { ctx, calls } = createExpressServiceHarness({
user: {
store_id: 100000,
},
expressSettingRows: [
{ id: 21, code: 'STO', name: '系统同码设置', express_code: 'STO', warehouse_id: 100000 },
{ id: 22, code: 'SF-SETTING', name: '顺丰设置', express_code: 'STO', warehouse_id: 100000 },
],
});
const service = new ExpressService(ctx);
const result = await service.getExpressList();
assert.equal(calls.getCache, 1);
assert.equal(calls.expressFindAll, 1);
assert.equal(calls.expressSettingFindAll, 1);
assert.deepEqual(result.slice(0, 2), [
{ code: 'STO', name: '顺丰', value: 'STO', label: '顺丰', is_system_setting: false, id: null, alias: null },
{ code: 'TB', name: '淘宝快递', value: 'TB', label: '淘宝快递', is_system_setting: false, id: null, alias: null },
]);
assert.deepEqual(result, [
{ code: 'STO', name: '顺丰', value: 'STO', label: '顺丰', is_system_setting: false, id: null, alias: null },
{ code: 'TB', name: '淘宝快递', value: 'TB', label: '淘宝快递', is_system_setting: false, id: null, alias: null },
{ code: 'SF-SETTING', name: 'SF-SETTING (顺丰)', value: 'SF-SETTING', label: 'SF-SETTING (顺丰)', express_code: 'STO', is_system_setting: true, id: 22, alias: '顺丰设置' },
]);
});
it('should load system express list and cache it with the system cache key when systemOnly is true', async () => {
const { ctx, calls } = createExpressServiceHarness({
rows: [
{ code: 'SF', name: '顺丰' },
],
});
const service = new ExpressService(ctx);
const result = await service.getExpressList(true);
assert.equal(calls.getCache, 1);
assert.equal(calls.expressFindAll, 1);
assert.equal(calls.expressSettingFindAll, 0);
assert.equal(calls.setCache, 1);
assert.equal(calls.cachePayload.cacheKey, 'express:list:system');
assert.equal(calls.cachePayload.ttl, 600);
assert.deepEqual(result, [
{ code: 'SF', name: '顺丰', value: 'SF', label: '顺丰', is_system_setting: false, id: null, alias: null },
]);
});
it('should return cached express list without querying database', async () => {
const cachedValue = [
{ code: 'SF', name: '顺丰', value: 'SF', label: '顺丰', is_system_setting: false, id: null, alias: null },
];
const { ctx, calls } = createExpressServiceHarness({
cachedValue,
});
const service = new ExpressService(ctx);
const result = await service.getExpressList();
assert.equal(calls.getCache, 1);
assert.equal(calls.expressFindAll, 0);
assert.equal(calls.setCache, 0);
assert.deepEqual(result, cachedValue);
});
it('should load express product types from database and cache them when cache is empty', async () => {
const { ctx, calls } = createExpressServiceHarness();
const service = new ExpressService(ctx);
const result = await service.getExpressProductTypeList();
assert.equal(calls.getCache, 1);
assert.equal(calls.expressProductTypeFindAll, 1);
assert.equal(calls.setCache, 1);
assert.equal(calls.cachePayload.cacheKey, 'express:product-type:list');
assert.equal(calls.cachePayload.ttl, 3600);
assert.deepEqual(result, [
{ code: 'SF-EXP', express_code: 'SF', name: '顺丰标准', value: 'SF-EXP', label: '顺丰标准' },
{ code: 'SF-ECON', express_code: 'SF', name: '顺丰经济', value: 'SF-ECON', label: '顺丰经济' },
]);
});
it('should load express product types by express code and cache them with code-specific key', async () => {
const { ctx, calls } = createExpressServiceHarness({
expressProductTypeRows: [
{ code: 'SF-EXP', name: '顺丰标准', express_code: 'SF' },
],
});
const service = new ExpressService(ctx);
const result = await service.getExpressProductTypeList('SF');
assert.equal(calls.getCache, 1);
assert.equal(calls.expressProductTypeFindAll, 1);
assert.deepEqual(calls.expressProductTypeFindAllQuery.where, { express_code: 'SF' });
assert.equal(calls.setCache, 1);
assert.equal(calls.cachePayload.cacheKey, 'express:product-type:list:SF');
assert.equal(calls.cachePayload.ttl, 3600);
assert.deepEqual(result, [
{ code: 'SF-EXP', express_code: 'SF', name: '顺丰标准', value: 'SF-EXP', label: '顺丰标准' },
]);
});
it('should return cached express product types without querying database', async () => {
const cachedValue = [
{ code: 'SF-EXP', express_code: 'SF', name: '顺丰标准', value: 'SF-EXP', label: '顺丰标准' },
];
const { ctx, calls } = createExpressServiceHarness({
cachedValue,
});
const service = new ExpressService(ctx);
const result = await service.getExpressProductTypeList('SF');
assert.equal(calls.getCache, 1);
assert.equal(calls.expressProductTypeFindAll, 0);
assert.equal(calls.setCache, 0);
assert.deepEqual(result, cachedValue);
});
it('should load system express list without merging warehouse settings', async () => {
const { ctx, calls } = createExpressServiceHarness({
rows: [
{ code: 'SF', name: '顺丰' },
],
});
const service = new ExpressService(ctx);
const result = await service.getSystemExpressList();
assert.equal(calls.getCache, 0);
assert.equal(calls.expressFindAll, 1);
assert.equal(calls.expressSettingFindAll, 0);
assert.deepEqual(result, [
{ code: 'SF', name: '顺丰', value: 'SF', label: '顺丰', is_system_setting: false, id: null, alias: null },
]);
});
it('should delegate index.getExpressList to the express service', async () => {
const { ctx } = createExpressServiceHarness();
let serviceCalls = 0;
let receivedSystemOnly = null;
let receivedExpressCode = null;
ctx.service = {
systems: {
express: {
async getExpressList(systemOnly, expressCode) {
serviceCalls += 1;
receivedSystemOnly = systemOnly;
receivedExpressCode = expressCode;
return [
{ code: 'STO', name: '顺丰', value: 'STO', label: '顺丰' },
];
},
},
},
};
const methodService = new IndexMethodService(ctx);
const result = await methodService.getExpressList({});
assert.equal(serviceCalls, 1);
assert.equal(receivedSystemOnly, false);
assert.equal(receivedExpressCode, '');
assert.equal(result.flag, 'success');
assert.equal(result.message, 'ok');
assert.equal(result.code, 200);
assert.deepEqual(result.data, [
{ code: 'STO', name: '顺丰', value: 'STO', label: '顺丰' },
]);
});
it('should delegate index.getExpressList with systemOnly to the express service', async () => {
const { ctx } = createExpressServiceHarness();
let serviceCalls = 0;
let receivedSystemOnly = null;
let receivedExpressCode = null;
ctx.service = {
systems: {
express: {
async getExpressList(systemOnly, expressCode) {
serviceCalls += 1;
receivedSystemOnly = systemOnly;
receivedExpressCode = expressCode;
return [
{ code: 'SF', name: '顺丰', value: 'SF', label: '顺丰' },
];
},
},
},
};
const methodService = new IndexMethodService(ctx);
const result = await methodService.getExpressList({ systemOnly: true });
assert.equal(serviceCalls, 1);
assert.equal(receivedSystemOnly, true);
assert.equal(receivedExpressCode, '');
assert.equal(result.flag, 'success');
assert.equal(result.message, 'ok');
assert.equal(result.code, 200);
assert.deepEqual(result.data, [
{ code: 'SF', name: '顺丰', value: 'SF', label: '顺丰' },
]);
});
it('should delegate index.getExpressList with express_code to the express service', async () => {
const { ctx } = createExpressServiceHarness();
let serviceCalls = 0;
let receivedSystemOnly = null;
let receivedExpressCode = null;
ctx.service = {
systems: {
express: {
async getExpressList(systemOnly, expressCode) {
serviceCalls += 1;
receivedSystemOnly = systemOnly;
receivedExpressCode = expressCode;
return [
{ code: 'SF-001', name: 'SF-001 (顺丰)', value: 'SF-001', label: 'SF-001 (顺丰)', express_code: 'SF' },
];
},
},
},
};
const methodService = new IndexMethodService(ctx);
const result = await methodService.getExpressList({ express_code: 'SF' });
assert.equal(serviceCalls, 1);
assert.equal(receivedSystemOnly, false);
assert.equal(receivedExpressCode, 'SF');
assert.equal(result.flag, 'success');
assert.equal(result.message, 'ok');
assert.equal(result.code, 200);
assert.deepEqual(result.data, [
{ code: 'SF-001', name: 'SF-001 (顺丰)', value: 'SF-001', label: 'SF-001 (顺丰)', express_code: 'SF' },
]);
});
it('should not read expressCode alias in index.getExpressList', async () => {
const { ctx } = createExpressServiceHarness();
let serviceCalls = 0;
let receivedSystemOnly = null;
let receivedExpressCode = null;
ctx.service = {
systems: {
express: {
async getExpressList(systemOnly, expressCode) {
serviceCalls += 1;
receivedSystemOnly = systemOnly;
receivedExpressCode = expressCode;
return [];
},
},
},
};
const methodService = new IndexMethodService(ctx);
const result = await methodService.getExpressList({ expressCode: 'SF' });
assert.equal(serviceCalls, 1);
assert.equal(receivedSystemOnly, false);
assert.equal(receivedExpressCode, '');
assert.equal(result.flag, 'success');
assert.equal(result.message, 'ok');
assert.equal(result.code, 200);
assert.deepEqual(result.data, []);
});
it('should return custom code list by system express_code for current warehouse', async () => {
const { ctx, calls } = createExpressServiceHarness({
user: {
store_id: 100000,
},
rows: [
{ code: 'SF', name: '顺丰' },
],
expressSettingRows: [
{ id: 31, code: 'SF-001', name: '顺丰设置1', express_code: 'SF', warehouse_id: 100000 },
{ id: 32, code: 'SF-002', name: '顺丰设置2', express_code: 'SF', warehouse_id: 100000 },
{ id: 33, code: 'SF', name: '同名自定义编码但系统编码不匹配', express_code: 'YTO', warehouse_id: 100000 },
],
});
const service = new ExpressService(ctx);
const result = await service.getExpressList(false, 'sf');
assert.equal(calls.getCache, 1);
assert.equal(calls.expressFindAll, 1);
assert.equal(calls.expressSettingFindAll, 1);
assert.equal(calls.cachePayload.cacheKey, 'express:list:100000:express:SF');
assert.deepEqual(calls.expressSettingFindAllQuery.where, {
warehouse_id: 100000,
express_code: 'SF',
});
assert.deepEqual(result, [
{ code: 'SF-001', name: 'SF-001 (顺丰)', value: 'SF-001', label: 'SF-001 (顺丰)', express_code: 'SF', is_system_setting: true, id: 31, alias: '顺丰设置1' },
{ code: 'SF-002', name: 'SF-002 (顺丰)', value: 'SF-002', label: 'SF-002 (顺丰)', express_code: 'SF', is_system_setting: true, id: 32, alias: '顺丰设置2' },
]);
});
it('should delegate index.getExpressProductTypeList to the express service', async () => {
const { ctx } = createExpressServiceHarness();
let serviceCalls = 0;
let receivedExpressCode = '';
ctx.service = {
systems: {
express: {
async getExpressProductTypeList(expressCode) {
serviceCalls += 1;
receivedExpressCode = expressCode;
return [
{ code: 'SF-EXP', express_code: 'SF', name: '顺丰标准', value: 'SF-EXP', label: '顺丰标准' },
];
},
},
},
};
const methodService = new IndexMethodService(ctx);
const result = await methodService.getExpressProductTypeList({ express_code: 'SF' });
assert.equal(serviceCalls, 1);
assert.equal(receivedExpressCode, 'SF');
assert.equal(result.flag, 'success');
assert.equal(result.message, 'ok');
assert.equal(result.code, 200);
assert.deepEqual(result.data, [
{ code: 'SF-EXP', express_code: 'SF', name: '顺丰标准', value: 'SF-EXP', label: '顺丰标准' },
]);
});
it('should sync PDD SF timed-delivery type_desc into express product types with idempotency', async () => {
const { ctx, calls } = createExpressServiceHarness({
expressProductTypeRows: [
{ id: 1, code: 'T6', name: '旧名称', express_code: 'SF' },
],
});
const service = new ExpressService(ctx);
const payload = {
shopExpressList: [
{
sys_express_code: 'SF',
accounts: [
{
services: [
{
service_code: 'TIMED-DELIVERY',
attributes: [
{
type_desc: '{"T6":"特快","T7":"标快"}',
},
],
},
],
},
],
},
{
sys_express_code: 'SF',
accounts: [
{
services: [
{
service_code: 'OTHER-SERVICE',
attributes: [
{
type_desc: '{"X1":"无效"}',
},
],
},
],
},
],
},
{
sys_express_code: 'YTO',
accounts: [
{
services: [
{
service_code: 'TIMED-DELIVERY',
attributes: [
{
type_desc: '{"Y1":"圆通"}',
},
],
},
],
},
],
},
],
};
const firstResult = await service.syncPddSfTimedDeliveryExpressProductTypes(payload);
const secondResult = await service.syncPddSfTimedDeliveryExpressProductTypes(payload);
assert.deepEqual(firstResult, {
createdCount: 1,
updatedCount: 1,
parsedCount: 2,
});
assert.deepEqual(secondResult, {
createdCount: 0,
updatedCount: 0,
parsedCount: 2,
});
assert.equal(calls.expressProductTypeCreate, 1);
assert.equal(calls.expressProductTypeUpdate, 1);
});
it('should group waybill orders by sys_platform_code and logistics_code before creating batches', async () => {
const { ctx } = createExpressServiceHarness({
orderDeliveryRows: [
{ id: 1, sys_platform_code: 'TAOBAO', logistics_code: 'STO' },
{ id: 2, sys_platform_code: 'TAOBAO', logistics_code: 'STO' },
{ id: 3, sys_platform_code: 'TAOBAO', logistics_code: 'YTO' },
{ id: 4, sys_platform_code: 'JD', logistics_code: 'STO' },
],
});
const service = new ExpressService(ctx);
const createWaybillCodeCalls = [];
service.createWaybillCode = async batch => {
createWaybillCodeCalls.push(batch);
return {
orders: batch,
waybill_codes: [],
};
};
it('should expand mixed business_key inputs into unique records while keeping grouping and batching intact', async () => {
const { ctx } = createExpressServiceHarness();
const service = new ExpressService(ctx);
const createWaybillCodeCalls = [];
service.createWaybillCode = async batch => {
createWaybillCodeCalls.push(batch);
return {
orders: batch,
waybill_codes: [],
};
};
const result = await service.createWaybillCodePipeline([
{ order_id: 1, business_key: [ 1 ], sys_platform_code: 'TAOBAO', logistics_code: 'STO' },
{ order_id: 2, business_key: [ 2, 3 ], sys_platform_code: 'TAOBAO', logistics_code: 'STO' },
{ order_id: 3, business_key: '4', sys_platform_code: 'TAOBAO', logistics_code: 'STO' },
{ order_id: 4, business_key: 5, sys_platform_code: 'TAOBAO', logistics_code: 'STO' },
{ order_id: 5, business_key: [ 6, '7' ], sys_platform_code: 'TAOBAO', logistics_code: 'STO' },
{ order_id: 6, business_key: [ 8, '9', 9 ], sys_platform_code: 'TAOBAO', logistics_code: 'STO' },
{ order_id: 7, business_key: [ 10, 11 ], sys_platform_code: 'TAOBAO', logistics_code: 'STO' },
{ order_id: 8, business_key: 12, sys_platform_code: 'TAOBAO', logistics_code: 'STO' },
{ order_id: 9, business_key: '13', sys_platform_code: 'JD', logistics_code: 'YTO' },
]);
assert.equal(createWaybillCodeCalls.length, 3);
assert.deepEqual(createWaybillCodeCalls.map(batch => batch.length), [ 10, 2, 1 ]);
assert.deepEqual(createWaybillCodeCalls.map(batch => `${batch[0].sys_platform_code}:${batch[0].logistics_code}`), [
'TAOBAO:STO',
'TAOBAO:STO',
'JD:YTO',
]);
assert.equal(result.orders.length, 13);
assert.equal(new Set(result.orders.map(item => `${item.order_id}:${item.business_key}`)).size, 13);
assert.deepEqual(result.skippedOrders, []);
});
const result = await service.createWaybillCodePipeline([
{ order_id: 1, business_key: 101, sys_platform_code: 'TAOBAO', logistics_code: 'STO' },
{ order_id: 2, business_key: 102, sys_platform_code: 'TAOBAO', logistics_code: 'STO' },
{ order_id: 3, business_key: 103, sys_platform_code: 'TAOBAO', logistics_code: 'YTO' },
{ order_id: 4, business_key: 104, sys_platform_code: 'JD', logistics_code: 'STO' },
]);
assert.equal(createWaybillCodeCalls.length, 3);
assert.deepEqual(createWaybillCodeCalls.map(batch => batch.map(item => `${item.sys_platform_code}:${item.logistics_code}`)), [
[ 'TAOBAO:STO', 'TAOBAO:STO' ],
[ 'TAOBAO:YTO' ],
[ 'JD:STO' ],
]);
assert.deepEqual(result.skippedOrders, []);
});
it('should expand array business_key values into unique normalized create orders', async () => {
const { ctx } = createExpressServiceHarness();
const service = new ExpressService(ctx);
const normalizedOrders = service.normalizeWaybillCreateOrders([
{
order_id: 11,
business_key: [ 301, 302, 302, 303 ],
sys_platform_code: 'TAOBAO',
logistics_code: 'STO',
express_platform_code: 'polyapi',
platform_code: 'polyapi',
},
]);
assert.deepEqual(normalizedOrders, [
{
order_id: 11,
business_key: 301,
sys_platform_code: 'TAOBAO',
logistics_code: 'STO',
platform_code: 'polyapi',
},
{
order_id: 11,
business_key: 302,
sys_platform_code: 'TAOBAO',
logistics_code: 'STO',
platform_code: 'polyapi',
},
{
order_id: 11,
business_key: 303,
sys_platform_code: 'TAOBAO',
logistics_code: 'STO',
platform_code: 'polyapi',
},
]);
});
it('should expand array business_key values before grouping and batching in pipeline', async () => {
const { ctx } = createExpressServiceHarness({
orderDeliveryRows: [
{ id: 1, sys_platform_code: 'TAOBAO', logistics_code: 'STO' },
{ id: 2, sys_platform_code: 'TAOBAO', logistics_code: 'STO' },
{ id: 3, sys_platform_code: 'JD', logistics_code: 'YTO' },
],
});
const service = new ExpressService(ctx);
const createWaybillCodeCalls = [];
service.createWaybillCode = async batch => {
createWaybillCodeCalls.push(batch);
return {
orders: batch,
waybill_codes: [],
};
};
const result = await service.createWaybillCodePipeline([
{
order_id: 1,
business_key: [ 401, 402 ],
sys_platform_code: 'TAOBAO',
logistics_code: 'STO',
},
{
order_id: 2,
business_key: 403,
sys_platform_code: 'TAOBAO',
logistics_code: 'STO',
},
{
order_id: 3,
business_key: [ 404, 405 ],
sys_platform_code: 'JD',
logistics_code: 'YTO',
},
]);
assert.equal(createWaybillCodeCalls.length, 2);
assert.deepEqual(createWaybillCodeCalls[0].map(item => item.business_key), [ 401, 402, 403 ]);
assert.deepEqual(createWaybillCodeCalls[1].map(item => item.business_key), [ 404, 405 ]);
assert.deepEqual(result.orders.map(item => item.business_key), [ 401, 402, 403, 404, 405 ]);
assert.deepEqual(result.skippedOrders, []);
});
it('should split waybill orders into batches with at most 10 items and call createWaybillCode sequentially', async () => {
const { ctx } = createExpressServiceHarness({
orderDeliveryRows: Array.from({ length: 21 }, (_, index) => ({
id: index + 1,
sys_platform_code: 'TAOBAO',
logistics_code: 'STO',
})),
});
const service = new ExpressService(ctx);
const createWaybillCodeCalls = [];
let inFlight = 0;
service.createWaybillCode = async batch => {
assert.equal(inFlight, 0);
inFlight += 1;
createWaybillCodeCalls.push(batch);
await Promise.resolve();
inFlight -= 1;
return {
orders: batch,
waybill_codes: [],
};
};
const orders = Array.from({ length: 21 }, (_, index) => ({
order_id: index + 1,
business_key: 200 + index,
sys_platform_code: 'TAOBAO',
logistics_code: 'STO',
}));
await service.createWaybillCodePipeline(orders);
assert.equal(createWaybillCodeCalls.length, 3);
assert.deepEqual(createWaybillCodeCalls.map(batch => batch.length), [ 10, 10, 1 ]);
});
it('should skip orders without sys_platform_code or logistics_code', async () => {
const { ctx } = createExpressServiceHarness({
orderDeliveryRows: [
{ id: 1, sys_platform_code: '', logistics_code: 'STO' },
{ id: 2, sys_platform_code: 'TAOBAO', logistics_code: '' },
{ id: 3, sys_platform_code: 'TAOBAO', logistics_code: 'STO' },
],
});
const service = new ExpressService(ctx);
const createWaybillCodeCalls = [];
service.createWaybillCode = async batch => {
createWaybillCodeCalls.push(batch);
return {
orders: batch,
waybill_codes: [],
};
};
const result = await service.createWaybillCodePipeline([
{ order_id: 1, business_key: 301, logistics_code: 'STO' },
{ order_id: 2, business_key: 302, sys_platform_code: 'TAOBAO' },
{ order_id: 3, business_key: 303, sys_platform_code: 'TAOBAO', logistics_code: 'STO' },
]);
assert.equal(createWaybillCodeCalls.length, 1);
assert.deepEqual(createWaybillCodeCalls[0], [
{
order_id: 3,
business_key: 303,
sys_platform_code: 'TAOBAO',
logistics_code: 'STO',
},
]);
assert.equal(result.skippedOrders.length, 2);
assert.deepEqual(result.skippedOrders.map(item => ({
order_id: item.order_id,
business_key: item.business_key,
reason: item.reason,
})), [
{ order_id: 1, business_key: 301, reason: '缺少 sys_platform_code 或 logistics_code' },
{ order_id: 2, business_key: 302, reason: '缺少 sys_platform_code 或 logistics_code' },
]);
});
});