864 lines
30 KiB
JavaScript
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' },
|
|
]);
|
|
});
|
|
});
|