liufumingren dc4894cb6d 1
2026-05-25 17:08:56 +08:00

1646 lines
49 KiB
JavaScript

'use strict';
const assert = require('node:assert/strict');
const IndexMethodService = require('../../../../app/service/systemMethods/index');
/**
* 创建 systemMethods.index 的最小测试桩环境。
*
* @return {{service: Object, ctx: Object, calls: Object}} 测试桩对象
*/
function createHarness() {
const calls = {
curl: 0,
getCacheAsync: 0,
syncPddSfTimedDeliveryExpressProductTypes: 0,
setCacheAsync: 0,
getExpressProductTypeList: 0,
getPrintPlatformList: 0,
printPlatformFindOne: 0,
printPlatformFindOneCalls: [],
expressFindAll: 0,
platformFindOne: 0,
shopCreate: 0,
};
const ctx = {
user: {
store_id: 100000,
},
app: {
formatDate() {
return '2026-05-24 12:00:00';
},
async getCacheAsync(key) {
calls.getCacheAsync += 1;
calls.getCacheAsyncPayload = key;
return undefined;
},
async setCacheAsync(key, value, ttl) {
calls.setCacheAsync += 1;
calls.setCacheAsyncPayload = {
key,
value,
ttl,
};
},
config: {
pdd: {
client_id: '1',
client_secret: 'testSecret',
},
qimen: {
appKey: 'tbAppKey',
security: 'tbAppSecret',
},
},
},
model: {
PrintPlatform: {
async findOne(options) {
calls.printPlatformFindOne += 1;
calls.printPlatformFindOnePayload = options;
calls.printPlatformFindOneCalls.push(options);
const platformCode = options && options.where && options.where.platform_code;
if (!platformCode) {
return null;
}
return {
platform_code: platformCode,
auth_base_url: 'https://oauth.example.com/auth?state=',
};
},
},
Platform: {
async findOne(options) {
calls.platformFindOne += 1;
calls.platformFindOnePayload = options;
const code = options && options.where && options.where.code;
if (code === 'TB') {
return {
code: 'TB',
auth_base_url: 'https://oauth.example.com/auth?state=',
};
}
return null;
},
},
Express: {
rawAttributes: {
code: { field: 'code' },
CAINIAO: { field: 'CAINIAO' },
PDD: { field: 'PDD' },
DYXD: { field: 'DYXD' },
KS: { field: 'KS' },
},
async findAll(options) {
calls.expressFindAll += 1;
calls.expressFindAllPayload = options;
return [];
},
},
Shop: {
async findOne() {
return null;
},
async findAll() {
return [];
},
async create(payload) {
calls.shopCreate += 1;
calls.shopCreatePayload = payload;
return payload;
},
},
},
logger: {
error() {},
info() {},
warn() {},
},
async curl(url, options) {
calls.curl += 1;
calls.request = { url, options };
return {
data: {
success: true,
code: 0,
},
};
},
};
const service = Object.create(IndexMethodService.prototype);
service.ctx = ctx;
service.app = ctx.app;
service.service = {
systems: {
express: {
async getExpressList() {
return [];
},
async getExpressProductTypeList(expressCode) {
calls.getExpressProductTypeList += 1;
calls.getExpressProductTypeListPayload = expressCode;
return [];
},
async syncPddSfTimedDeliveryExpressProductTypes(payload) {
calls.syncPddSfTimedDeliveryExpressProductTypes += 1;
calls.syncPayload = payload;
return {
createdCount: 0,
updatedCount: 0,
parsedCount: 0,
};
},
},
setting: {
expressInterface: {
async getPrintPlatformList() {
calls.getPrintPlatformList += 1;
return [
{
id: 1,
code: 'CAINIAO',
name: '菜鸟电子面单',
value: 'CAINIAO',
label: '菜鸟电子面单',
platform_code: 'CAINIAO',
platform_name: '菜鸟电子面单',
platid: '1001',
},
];
},
},
},
sign: {
signTopRequest(params) {
calls.tbSignParams = { ...params };
return 'TB_SIGN';
},
},
},
};
return {
service,
ctx,
calls,
};
}
describe('test/app/service/systemMethods/index.test.js', () => {
it('应按拼多多官方示例参数生成签名并发起请求', async () => {
const { service, calls } = createHarness();
const result = await service.test({
type: 'pdd.order.number.list.get',
timestamp: '1480411125',
dataType: 'XML',
accessToken: 'asd78172s8ds9a921j9qqwda12312w1w21211',
order_status: '1',
page: '1',
page_size: '10',
});
assert.equal(calls.curl, 1);
assert.equal(calls.request.url, 'https://gw-api.pinduoduo.com/api/router');
assert.equal(calls.request.options.method, 'POST');
assert.equal(calls.request.options.headers['Content-Type'], 'application/json');
assert.equal(calls.request.options.data.sign, 'E4DE3ED21002510DED352819E7AE6775');
assert.equal(result.flag, 'success');
assert.equal(result.code, 200);
assert.equal(result.data.requestBody.sign, 'E4DE3ED21002510DED352819E7AE6775');
assert.deepEqual(result.data.response, { success: true, code: 0 });
});
it('缺少 type 时应直接返回参数错误', async () => {
const { service, calls } = createHarness();
const result = await service.test({
page: '1',
});
assert.equal(calls.curl, 0);
assert.equal(result.flag, 'failure');
assert.equal(result.code, 400);
assert.equal(result.message, 'type 不能为空');
});
it('应兼容 access_token 等下划线参数命名', async () => {
const { service, calls } = createHarness();
const result = await service.test({
type: 'pdd.order.number.list.get',
timestamp: '1480411125',
data_type: 'XML',
access_token: 'asd78172s8ds9a921j9qqwda12312w1w21211',
order_status: '1',
page: '1',
page_size: '10',
});
assert.equal(calls.curl, 1);
assert.equal(calls.request.options.data.access_token, 'asd78172s8ds9a921j9qqwda12312w1w21211');
assert.equal(calls.request.options.data.sign, 'E4DE3ED21002510DED352819E7AE6775');
assert.equal(result.flag, 'success');
assert.equal(result.code, 200);
});
it('getShopExpressList 在 PDD 下 SF 且无 TIMED-DELIVERY 时应补齐时效服务', async () => {
const { service, ctx, calls } = createHarness();
ctx.model.Shop.findOne = async () => ({
get() {
return {
id: 12,
warehouse_id: 100000,
platform_code: 'PDD',
access_token: 'ACCESS_TOKEN',
};
},
});
service.service.systems.express.getExpressList = async isEnabled => {
assert.equal(isEnabled, true);
return [
{
code: 'SF',
name: '顺丰',
PDD: 'SF-PDD',
},
];
};
service.service.systems.express.getExpressProductTypeList = async expressCode => {
calls.getExpressProductTypeList += 1;
calls.getExpressProductTypeListPayload = expressCode;
return [
{ code: 'T6', name: '特快' },
{ code: 'T7', name: '标快' },
];
};
service.requestPddWaybillSearch = async accessToken => {
assert.equal(accessToken, 'ACCESS_TOKEN');
return {
pdd_waybill_search_response: {
request_id: 'REQ-001',
waybill_apply_subscription_cols: [
{
wp_code: 'SF-PDD',
wp_type: '1',
branch_account_cols: [
{
branch_code: 'PDD-BRANCH-001',
branch_name: '拼多多直营网点',
},
],
},
{
wp_code: 'UNKNOWN-PDD',
wp_type: '2',
branch_account_cols: [],
},
],
},
};
};
const result = await service.getShopExpressList({
shop_id: 12,
});
assert.equal(result.flag, 'success');
assert.equal(result.code, 200);
assert.equal(result.data.shop_id, 12);
assert.equal(result.data.platform_code, 'PDD');
assert.equal(result.data.list[0].wp_name, '顺丰');
assert.equal(result.data.list[0].sys_express_code, 'SF');
assert.deepEqual(result.data.list[0].accounts[0].services, []);
assert.equal(result.data.list[1].wp_name, '');
assert.equal(result.data.list[1].sys_express_code, '');
assert.equal(calls.syncPddSfTimedDeliveryExpressProductTypes, 0);
assert.equal(calls.getExpressProductTypeList, 0);
});
it('getShopExpressList 在 TB 下 SF 且无 TIMED-DELIVERY 时也应补齐时效服务', async () => {
const { service, ctx, calls } = createHarness();
ctx.model.Shop.findOne = async () => ({
get() {
return {
id: 23,
warehouse_id: 100000,
platform_code: 'CAINIAO',
access_token: 'TB_ACCESS_TOKEN',
printPlatform: {
platform_code: 'CAINIAO',
platform_name: '菜鸟电子面单',
},
};
},
});
service.service.systems.express.getExpressList = async isEnabled => {
assert.equal(isEnabled, true);
return [
{
code: 'SF',
name: '顺丰',
CAINIAO: 'SF',
},
];
};
service.service.systems.express.getExpressProductTypeList = async expressCode => {
calls.getExpressProductTypeList += 1;
calls.getExpressProductTypeListPayload = expressCode;
return [
{ code: 'T6', name: '特快' },
];
};
service.requestTbWaybillSearch = async payload => {
assert.deepEqual(payload, {
accessToken: 'TB_ACCESS_TOKEN',
cpCode: 'SF',
});
return {
cainiao_waybill_ii_search_response: {
request_id: 'TB-REQ-023',
modules: {
waybill_apply_subscription_cols: {
waybill_apply_subscription_info: {
cp_code: 'SF',
cp_name: '顺丰',
waybill_type: 'STANDARD',
branch_account_cols: {
waybill_branch_account: {
branch_name: '顺丰直营网点',
customer_code_list: {
string: 'SF-TB-001',
},
service_info_cols: {
service_info_dto: [
{
service_code: 'SPECIAL',
service_name: '普通服务',
service_desc: '非定时服务',
required: false,
service_attributes: {
service_attribute_dto: {
attribute_code: 'SPECIAL_CODE',
attribute_name: '服务编码',
attribute_type: 'INPUT',
type_desc: '文本',
},
},
},
],
},
},
},
},
},
},
},
};
};
const result = await service.getShopExpressList({
shop_id: 23,
cp_code: 'SF',
});
assert.equal(result.flag, 'success');
assert.equal(result.code, 200);
assert.equal(result.data.platform_code, 'CAINIAO');
assert.deepEqual(result.data.list[0].accounts[0].services, [
{
service_code: 'SPECIAL',
service_name: '普通服务',
service_desc: '非定时服务',
required: false,
attributes: [
{
attribute_code: 'SPECIAL_CODE',
attribute_name: '服务编码',
attribute_type: 'INPUT',
type_desc: '文本',
},
],
},
]);
assert.equal(calls.getExpressProductTypeList, 0);
assert.equal(calls.syncPddSfTimedDeliveryExpressProductTypes, 0);
});
it('getShopExpressList 在 SF 且已有 TIMED-DELIVERY 时不应重复追加', async () => {
const { service, ctx, calls } = createHarness();
ctx.model.Shop.findOne = async () => ({
get() {
return {
id: 21,
warehouse_id: 100000,
platform_code: 'PDD',
access_token: 'ACCESS_TOKEN',
};
},
});
service.service.systems.express.getExpressList = async () => ([
{
code: 'SF',
name: '顺丰',
PDD: 'SF-PDD',
},
]);
service.requestPddWaybillSearch = async () => ({
pdd_waybill_search_response: {
request_id: 'REQ-021',
waybill_apply_subscription_cols: [
{
wp_code: 'SF-PDD',
wp_type: '1',
branch_account_cols: [
{
branch_code: 'PDD-BRANCH-021',
branch_name: '顺丰网点',
service_info_cols: [
{
service_code: 'TIMED-DELIVERY',
service_name: '定时派送',
service_desc: '顺丰定时派送',
required: false,
service_attributes: [
{
attribute_code: 'PRODUCT_TYPE',
attribute_name: '产品类型',
attribute_type: 'SELECT',
type_desc: '{"T6":"特快"}',
},
],
},
],
},
],
},
],
},
});
const result = await service.getShopExpressList({
shop_id: 21,
});
assert.equal(result.flag, 'success');
assert.equal(result.data.list[0].accounts[0].services.length, 1);
assert.equal(result.data.list[0].accounts[0].services[0].service_code, 'TIMED-DELIVERY');
assert.equal(calls.getExpressProductTypeList, 0);
});
it('getShopExpressList 在非 SF 快递时不应补齐 TIMED-DELIVERY', async () => {
const { service, ctx, calls } = createHarness();
ctx.model.Shop.findOne = async () => ({
get() {
return {
id: 22,
warehouse_id: 100000,
platform_code: 'PDD',
access_token: 'ACCESS_TOKEN',
};
},
});
service.service.systems.express.getExpressList = async () => ([
{
code: 'YTO',
name: '圆通',
PDD: 'YTO-PDD',
},
]);
service.requestPddWaybillSearch = async () => ({
pdd_waybill_search_response: {
request_id: 'REQ-022',
waybill_apply_subscription_cols: [
{
wp_code: 'YTO-PDD',
wp_type: '1',
branch_account_cols: [
{
branch_code: 'PDD-BRANCH-022',
branch_name: '圆通网点',
service_info_cols: [],
},
],
},
],
},
});
const result = await service.getShopExpressList({
shop_id: 22,
});
assert.equal(result.flag, 'success');
assert.deepEqual(result.data.list[0].accounts[0].services, []);
assert.equal(calls.getExpressProductTypeList, 0);
});
it('getShopExpressList 应仅在拼多多顺丰定时派送场景触发产品类型同步', async () => {
const { service, ctx, calls } = createHarness();
ctx.model.Shop.findOne = async () => ({
get() {
return {
id: 13,
warehouse_id: 100000,
platform_code: 'PDD',
access_token: 'ACCESS_TOKEN',
};
},
});
service.service.systems.express.getExpressList = async () => ([
{
code: 'SF',
name: '顺丰',
PDD: 'SF-PDD',
},
]);
service.requestPddWaybillSearch = async () => ({
pdd_waybill_search_response: {
request_id: 'REQ-002',
waybill_apply_subscription_cols: [
{
wp_code: 'SF-PDD',
wp_type: '1',
branch_account_cols: [
{
branch_code: 'PDD-BRANCH-002',
branch_name: '顺丰网点',
service_info_cols: [
{
service_code: 'TIMED-DELIVERY',
service_name: '定时派送',
service_desc: '顺丰定时派送',
required: false,
service_attributes: [
{
attribute_code: 'PRODUCT_TYPE',
attribute_name: '产品类型',
attribute_type: 'SELECT',
type_desc: '{"T6":"特快","T7":"标快"}',
},
],
},
],
},
],
},
],
},
});
const result = await service.getShopExpressList({
shop_id: 13,
});
assert.equal(result.flag, 'success');
assert.equal(result.code, 200);
assert.equal(calls.syncPddSfTimedDeliveryExpressProductTypes, 1);
assert.deepEqual(calls.syncPayload, {
shopExpressList: result.data.list,
});
});
it('getShopExpressList 应将淘宝菜鸟响应转换为统一结构', async () => {
const { service, ctx } = createHarness();
ctx.model.Shop.findOne = async () => ({
get() {
return {
id: 18,
warehouse_id: 100000,
platform_code: 'CAINIAO',
access_token: 'TB_ACCESS_TOKEN',
printPlatform: {
platform_code: 'CAINIAO',
platform_name: '菜鸟电子面单',
},
};
},
});
service.service.systems.express.getExpressList = async isEnabled => {
assert.equal(isEnabled, true);
return [
{
code: 'YTO_SYS',
name: '圆通速递',
CAINIAO: 'YTO',
},
];
};
service.requestTbWaybillSearch = async payload => {
assert.deepEqual(payload, {
accessToken: 'TB_ACCESS_TOKEN',
cpCode: 'YTO',
});
return {
cainiao_waybill_ii_search_response: {
request_id: 'TB-REQ-001',
modules: {
waybill_apply_subscription_cols: {
waybill_apply_subscription_info: {
cp_code: 'YTO',
cp_name: '圆通',
waybill_type: 'STANDARD',
branch_account_cols: {
waybill_branch_account: {
branch_name: '杭州转运中心',
quantity: 20,
cancel_quantity: 2,
allocated_quantity: 6,
customer_code_list: {
string: 'CUST-001',
},
address_dto: {
province: '浙江省',
city: '杭州市',
district: '余杭区',
detail: '文一西路1号',
},
service_info_dto: {
service_code: 'SEND_TIME',
service_name: '派送时效',
service_desc: '预约派送',
required: true,
service_attribute_dto: {
attribute_code: 'TIME_RANGE',
attribute_name: '时段',
attribute_type: 'SELECT',
type_desc: '枚举',
},
},
},
},
},
},
},
},
};
};
const result = await service.getShopExpressList({
shop_id: 18,
cp_code: 'YTO',
});
assert.equal(result.flag, 'success');
assert.equal(result.code, 200);
assert.equal(result.data.shop_id, 18);
assert.equal(result.data.platform_code, 'CAINIAO');
assert.deepEqual(result.data.list[0], {
wp_code: 'YTO',
wp_name: '圆通速递',
sys_express_code: 'YTO_SYS',
wp_type: 'STANDARD',
accounts: [
{
branch_code: 'CUST-001',
branch_name: '杭州转运中心',
quantity: 20,
cancel_quantity: 2,
recycled_quantity: 0,
allocated_quantity: 6,
customer_code_list: [ 'CUST-001' ],
ship_addresses: [
{
country: '中国',
province: '浙江省',
city: '杭州市',
district: '余杭区',
detail: '文一西路1号',
full_address: '',
},
],
services: [
{
service_code: 'SEND_TIME',
service_name: '派送时效',
service_desc: '预约派送',
required: true,
attributes: [
{
attribute_code: 'TIME_RANGE',
attribute_name: '时段',
attribute_type: 'SELECT',
type_desc: '枚举',
},
],
},
],
},
],
});
});
it('getShopExpressList 应过滤淘宝代收货款、定时派送、空属性服务并保留普通服务', async () => {
const { service, ctx } = createHarness();
ctx.model.Shop.findOne = async () => ({
get() {
return {
id: 19,
warehouse_id: 100000,
platform_code: 'CAINIAO',
access_token: 'TB_ACCESS_TOKEN',
printPlatform: {
platform_code: 'CAINIAO',
platform_name: '菜鸟电子面单',
},
};
},
});
service.service.systems.express.getExpressList = async () => ([
{
code: 'ZTO_SYS',
name: '中通快递',
CAINIAO: 'ZTO',
},
]);
service.requestTbWaybillSearch = async () => ({
cainiao_waybill_ii_search_response: {
request_id: 'TB-REQ-002',
modules: {
waybill_apply_subscription_cols: {
waybill_apply_subscription_info: {
cp_code: 'ZTO',
cp_name: '中通',
waybill_type: 'STANDARD',
branch_account_cols: {
waybill_branch_account: {
branch_name: '上海分拨中心',
customer_code_list: {
string: 'CUST-002',
},
shipp_address_cols: {
address_dto: {
province: '上海市',
city: '上海市',
district: '青浦区',
detail: '华徐公路99号',
},
},
service_info_cols: {
service_info_dto: [
{
service_code: 'COD',
service_name: '货到付款',
service_desc: '签收收款',
required: false,
service_attributes: {
service_attribute_dto: {
attribute_code: 'AMOUNT_LIMIT',
attribute_name: '金额限制',
attribute_type: 'INPUT',
type_desc: '文本',
},
},
},
{
service_code: 'INTERCEPT_NOTE',
service_name: '拦截件',
service_desc: '异常件拦截服务',
required: false,
service_attributes: {
service_attribute_dto: {
attribute_code: 'INTERCEPT_REASON',
attribute_name: '拦截原因',
attribute_type: 'INPUT',
type_desc: '文本',
},
},
},
{
service_code: 'APPOINTMENT_DELIVERY',
service_name: '定时派送',
service_desc: '预约时间段配送',
required: false,
service_attributes: {
service_attribute_dto: {
attribute_code: 'DELIVERY_TIME',
attribute_name: '派送时间',
attribute_type: 'SELECT',
type_desc: '枚举',
},
},
},
{
service_code: 'TRADE_IN',
service_name: '上门取旧换新',
service_desc: '支持上门取旧换新服务',
required: false,
service_attributes: {
service_attribute_dto: {
attribute_code: 'TRADE_IN_NOTICE',
attribute_name: '换新说明',
attribute_type: 'INPUT',
type_desc: '文本',
},
},
},
{
service_code: 'EMPTY_ATTR_SERVICE',
service_name: '短信通知',
service_desc: '普通服务但无属性',
required: false,
service_attributes: {
service_attribute_dto: [],
},
},
{
service_code: 'INSURE',
service_name: '运费险',
service_desc: '普通增值服务',
required: true,
service_attributes: {
service_attribute_dto: {
attribute_code: 'INSURE_TYPE',
attribute_name: '投保类型',
attribute_type: 'SELECT',
type_desc: '枚举',
},
},
},
],
},
},
},
},
},
},
},
});
const result = await service.getShopExpressList({
shop_id: 19,
cp_code: 'ZTO',
});
assert.equal(result.flag, 'success');
assert.equal(result.data.list[0].accounts[0].ship_addresses[0].province, '上海市');
assert.deepEqual(result.data.list[0].accounts[0].services, [
{
service_code: 'INSURE',
service_name: '运费险',
service_desc: '普通增值服务',
required: true,
attributes: [
{
attribute_code: 'INSURE_TYPE',
attribute_name: '投保类型',
attribute_type: 'SELECT',
type_desc: '枚举',
},
],
},
]);
});
it('getShopExpressList 应提取淘宝 type_desc.desc 并保留扁平 JSON 字符串', async () => {
const { service, ctx } = createHarness();
ctx.model.Shop.findOne = async () => ({
get() {
return {
id: 20,
warehouse_id: 100000,
platform_code: 'CAINIAO',
access_token: 'TB_ACCESS_TOKEN',
printPlatform: {
platform_code: 'CAINIAO',
platform_name: '菜鸟电子面单',
},
};
},
});
service.service.systems.express.getExpressList = async () => ([
{
code: 'SF_SYS',
name: '顺丰速运',
CAINIAO: 'SF',
},
]);
service.requestTbWaybillSearch = async () => ({
cainiao_waybill_ii_search_response: {
request_id: 'TB-REQ-003',
modules: {
waybill_apply_subscription_cols: {
waybill_apply_subscription_info: {
cp_code: 'SF',
cp_name: '顺丰',
waybill_type: 'STANDARD',
branch_account_cols: {
waybill_branch_account: {
branch_name: '顺丰直营网点',
customer_code_list: {
string: 'CUST-003',
},
service_info_dto: {
service_code: 'SPECIAL',
service_name: '特殊服务',
service_desc: '测试归一化',
required: true,
service_attribute_dto: [
{
attribute_code: 'EXPRESS_TYPE',
attribute_name: '快递类型',
attribute_type: 'SELECT',
type_desc: '{"desc":{"1":"标准快递","2":"特惠专配"},"required":true,"type":"enum"}',
},
{
attribute_code: 'PRODUCT_TYPE',
attribute_name: '产品类型',
attribute_type: 'SELECT',
type_desc: '{"T6":"特快","T7":"标快"}',
},
],
},
},
},
},
},
},
},
});
const result = await service.getShopExpressList({
shop_id: 20,
cp_code: 'SF',
});
assert.equal(result.flag, 'success');
assert.deepEqual(result.data.list[0].accounts[0].services[0].attributes, [
{
attribute_code: 'EXPRESS_TYPE',
attribute_name: '快递类型',
attribute_type: 'SELECT',
type_desc: '{"1":"标准快递","2":"特惠专配"}',
},
{
attribute_code: 'PRODUCT_TYPE',
attribute_name: '产品类型',
attribute_type: 'SELECT',
type_desc: '{"T6":"特快","T7":"标快"}',
},
]);
});
it('getCainiaoStfTemplates 应直接查询公共模板列表且不依赖店铺上下文', async () => {
const { service, ctx, calls } = createHarness();
let shopQueryCount = 0;
let stdTemplateRequestCount = 0;
let waybillSearchCallCount = 0;
ctx.model.Shop.findAll = async () => {
shopQueryCount += 1;
return [];
};
service.requestTbWaybillSearch = async () => {
waybillSearchCallCount += 1;
throw new Error('不应调用 cainiao.waybill.ii.search');
};
service.requestTbCainiaoStdTemplates = async () => {
stdTemplateRequestCount += 1;
return {
cainiao_cloudprint_stdtemplates_get_response: {
result: {
datas: [
{
cp_code: 'YTO',
brand_code: 'YTO',
success: true,
standard_templates: [
{
standard_template_id: 'TPL-001',
standard_template_name: '圆通标准模板',
standard_template_url: 'https://example.com/tpl-001',
},
{
standard_template_id: 'TPL-002',
standard_template_name: '圆通扩展模板',
standard_template_url: 'https://example.com/tpl-002',
},
],
},
{
brand_code: 'ZTO',
success: false,
error_code: 'NO_TEMPLATE_PERMISSION',
error_message: '该快递公司暂未返回模板',
standard_templates: [],
},
],
},
},
};
};
ctx.model.Express.findAll = async options => {
calls.expressFindAll += 1;
calls.expressFindAllPayload = options;
return [
{
code: 'YTO',
CAINIAO: 'YTO',
},
];
};
const result = await service.getCainiaoStfTemplates({
express_code: 'yto',
});
assert.equal(shopQueryCount, 0);
assert.equal(stdTemplateRequestCount, 1);
assert.equal(waybillSearchCallCount, 0);
assert.equal(calls.expressFindAll, 1);
assert.deepEqual(calls.expressFindAllPayload.where, {
CAINIAO: 'YTO',
});
assert.equal(result.flag, 'success');
assert.equal(result.code, 200);
assert.deepEqual(result.data, {
platform_code: 'CAINIAO',
express_code: 'YTO',
responseData: {
cainiao_cloudprint_stdtemplates_get_response: {
result: {
datas: [
{
cp_code: 'YTO',
brand_code: 'YTO',
success: true,
standard_templates: [
{
standard_template_id: 'TPL-001',
standard_template_name: '圆通标准模板',
standard_template_url: 'https://example.com/tpl-001',
},
{
standard_template_id: 'TPL-002',
standard_template_name: '圆通扩展模板',
standard_template_url: 'https://example.com/tpl-002',
},
],
},
],
},
},
},
});
});
it('getCainiaoStfTemplates 在缓存命中时不应请求淘宝公共模板接口', async () => {
const { service, calls } = createHarness();
const cachedResponseData = {
cainiao_cloudprint_stdtemplates_get_response: {
result: {
datas: [
{
cp_code: 'YTO',
standard_templates: [],
},
{
cp_code: 'ZTO',
standard_templates: [],
},
],
},
},
};
let stdTemplateRequestCount = 0;
service.app.getCacheAsync = async key => {
calls.getCacheAsync += 1;
calls.getCacheAsyncPayload = key;
return cachedResponseData;
};
service.requestTbCainiaoStdTemplates = async () => {
stdTemplateRequestCount += 1;
throw new Error('命中缓存时不应发起淘宝请求');
};
service.ctx.model.Express.findAll = async options => {
calls.expressFindAll += 1;
calls.expressFindAllPayload = options;
return [
{
code: 'YTO',
CAINIAO: 'YTO',
},
];
};
const result = await service.getCainiaoStfTemplates({
express_code: 'YTO',
});
assert.equal(calls.getCacheAsync, 1);
assert.equal(calls.getCacheAsyncPayload, 'index:cainiao:stfTemplates:responseData');
assert.equal(stdTemplateRequestCount, 0);
assert.equal(calls.expressFindAll, 1);
assert.equal(calls.setCacheAsync, 0);
assert.equal(result.flag, 'success');
assert.equal(result.code, 200);
assert.deepEqual(result.data, {
platform_code: 'CAINIAO',
express_code: 'YTO',
responseData: {
cainiao_cloudprint_stdtemplates_get_response: {
result: {
datas: [
{
cp_code: 'YTO',
standard_templates: [],
},
],
},
},
},
});
});
it('getCainiaoStfTemplates 在缓存未命中时应请求淘宝并写入 1 小时缓存', async () => {
const { service, calls } = createHarness();
const responseData = {
cainiao_cloudprint_stdtemplates_get_response: {
result: {
datas: [
{
cp_code: 'STO',
standard_templates: [
{
standard_template_id: 'TPL-100',
},
],
},
],
},
},
};
let stdTemplateRequestCount = 0;
service.requestTbCainiaoStdTemplates = async () => {
stdTemplateRequestCount += 1;
return responseData;
};
service.ctx.model.Express.findAll = async options => {
calls.expressFindAll += 1;
calls.expressFindAllPayload = options;
return [
{
code: 'STO',
CAINIAO: 'STO',
},
];
};
const result = await service.getCainiaoStfTemplates({
express_code: 'STO',
});
assert.equal(calls.getCacheAsync, 1);
assert.equal(calls.getCacheAsyncPayload, 'index:cainiao:stfTemplates:responseData');
assert.equal(stdTemplateRequestCount, 1);
assert.equal(calls.expressFindAll, 1);
assert.equal(calls.setCacheAsync, 1);
assert.deepEqual(calls.setCacheAsyncPayload, {
key: 'index:cainiao:stfTemplates:responseData',
value: responseData,
ttl: 3600,
});
assert.equal(result.flag, 'success');
assert.equal(result.code, 200);
assert.deepEqual(result.data, {
platform_code: 'CAINIAO',
express_code: 'STO',
responseData,
});
});
it('getPrintPlatformTemplateList 应按入参平台编码与 express_code 过滤模板并写入对应缓存键', async () => {
const { service, calls } = createHarness();
const responseData = {
cainiao_cloudprint_stdtemplates_get_response: {
result: {
datas: [
{
cp_code: 'YTO',
standard_templates: [
{
standard_template_id: 'TPL-YTO-1',
},
],
},
{
cp_code: 'ZTO',
standard_templates: [
{
standard_template_id: 'TPL-ZTO-1',
},
],
},
],
},
},
};
service.requestTbCainiaoStdTemplates = async () => responseData;
service.ctx.model.Express.findAll = async options => {
calls.expressFindAll += 1;
calls.expressFindAllPayload = options;
return [
{
code: 'YTO',
CAINIAO: 'YTO',
},
];
};
const result = await service.getPrintPlatformTemplateList({
platform_code: 'cainiao',
express_code: 'yto',
});
assert.equal(calls.getCacheAsync, 1);
assert.equal(calls.getCacheAsyncPayload, 'index:cainiao:stfTemplates:responseData');
assert.equal(calls.expressFindAll, 1);
assert.equal(calls.setCacheAsync, 1);
assert.deepEqual(calls.setCacheAsyncPayload, {
key: 'index:cainiao:stfTemplates:responseData',
value: responseData,
ttl: 3600,
});
assert.equal(result.flag, 'success');
assert.equal(result.code, 200);
assert.deepEqual(result.data, {
platform_code: 'CAINIAO',
express_code: 'YTO',
responseData: {
cainiao_cloudprint_stdtemplates_get_response: {
result: {
datas: [
{
cp_code: 'YTO',
standard_templates: [
{
standard_template_id: 'TPL-YTO-1',
},
],
},
],
},
},
},
});
});
it('getPrintPlatformTemplateList 应识别 standard_templates 子项中的 brand_code 并仅保留命中模板', async () => {
const { service, calls } = createHarness();
const responseData = {
cainiao_cloudprint_stdtemplates_get_response: {
result: {
datas: [
{
cp_code: 'SF',
standard_templates: [
{
brand_code: 'SF',
standard_template_id: 'TPL-SF-TOP-1',
},
{
brand_code: 'YTO',
standard_template_id: 'TPL-SF-TOP-2',
},
],
},
{
cp_code: 'CAINIAO_COMMON',
standard_templates: {
standard_template_do: [
{
brand_code: 'SF',
standard_template_id: 'TPL-SF-NESTED-1',
},
{
brand_code: 'YTO',
standard_template_id: 'TPL-YTO-NESTED-1',
},
],
},
},
{
cp_code: 'YTO',
standard_templates: {
standard_template_do: [
{
brand_code: 'YTO',
standard_template_id: 'TPL-YTO-ONLY-1',
},
],
},
},
],
},
},
};
service.requestTbCainiaoStdTemplates = async () => responseData;
service.ctx.model.Express.findAll = async options => {
calls.expressFindAll += 1;
calls.expressFindAllPayload = options;
return [
{
code: 'SF',
CAINIAO: 'SF',
},
];
};
const result = await service.getPrintPlatformTemplateList({
platform_code: 'CAINIAO',
express_code: 'sf',
});
assert.equal(calls.expressFindAll, 1);
assert.deepEqual(result.data, {
platform_code: 'CAINIAO',
express_code: 'SF',
responseData: {
cainiao_cloudprint_stdtemplates_get_response: {
result: {
datas: [
{
cp_code: 'SF',
standard_templates: [
{
brand_code: 'SF',
standard_template_id: 'TPL-SF-TOP-1',
},
{
brand_code: 'YTO',
standard_template_id: 'TPL-SF-TOP-2',
},
],
},
{
cp_code: 'CAINIAO_COMMON',
standard_templates: {
standard_template_do: [
{
brand_code: 'SF',
standard_template_id: 'TPL-SF-NESTED-1',
},
],
},
},
],
},
},
},
});
});
it('getPrintPlatformTemplateList 对未实现平台应返回空对象并按平台维度缓存', async () => {
const { service, calls } = createHarness();
const result = await service.getPrintPlatformTemplateList({
platformCode: 'pdd',
express_code: 'SF',
});
assert.equal(calls.getCacheAsync, 1);
assert.equal(calls.getCacheAsyncPayload, 'index:printPlatform:PDD:templates:responseData');
assert.equal(calls.setCacheAsync, 1);
assert.deepEqual(calls.setCacheAsyncPayload, {
key: 'index:printPlatform:PDD:templates:responseData',
value: {},
ttl: 3600,
});
assert.equal(result.flag, 'success');
assert.equal(result.code, 200);
assert.deepEqual(result.data, {
platform_code: 'PDD',
express_code: 'SF',
responseData: {},
});
});
it('getPrintPlatformTemplateList 缺少 express_code 时应返回参数错误', async () => {
const { service, calls } = createHarness();
const result = await service.getPrintPlatformTemplateList({
platform_code: 'cainiao',
});
assert.equal(result.flag, 'failure');
assert.equal(result.code, 400);
assert.equal(result.message, 'express_code 不能为空');
assert.equal(calls.getCacheAsync, 0);
assert.equal(calls.setCacheAsync, 0);
});
it('getPlatformOauthLink 应以打印平台校验店铺平台码,并使用打印平台 OAuth 配置生成 CAINIAO 状态', async () => {
const { service, calls } = createHarness();
const result = await service.getPlatformOauthLink({
platform_code: 'cainiao',
});
assert.equal(result.flag, 'success');
assert.equal(result.code, 200);
assert.equal(calls.printPlatformFindOne, 3);
assert.equal(calls.platformFindOne, 0);
assert.equal(
calls.printPlatformFindOneCalls.some(call => (
Array.isArray(call && call.attributes)
&& call.attributes.includes('auth_base_url')
)),
true
);
assert.equal(calls.shopCreate, 1);
assert.equal(calls.shopCreatePayload.platform_code, 'CAINIAO');
assert.equal(result.data.platform_code, 'CAINIAO');
assert.match(String(result.data.oauth_link || ''), /CAINIAO_/);
});
it('getPlatformOauthLink 应从打印平台表读取 auth_base_url', async () => {
const { service, ctx, calls } = createHarness();
ctx.model.PrintPlatform.findOne = async options => {
calls.printPlatformFindOne += 1;
calls.printPlatformFindOnePayload = options;
calls.printPlatformFindOneCalls.push(options);
if (!options || !options.attributes) {
return {
platform_code: 'PDD',
};
}
return {
platform_code: 'PDD',
auth_base_url: 'https://pdd.example.com/oauth?state=',
};
};
const result = await service.getPlatformOauthLink({
platform_code: 'PDD',
});
assert.equal(result.flag, 'success');
assert.equal(result.code, 200);
assert.equal(calls.platformFindOne, 0);
assert.match(String(result.data.oauth_link || ''), /^https:\/\/pdd\.example\.com\/oauth\?state=/);
});
it('getShopList 应携带打印平台名称并按打印平台编码过滤', async () => {
const { service, ctx } = createHarness();
ctx.model.Shop.findAll = async options => {
assert.equal(options.where.platform_code, 'CAINIAO');
assert.equal(Array.isArray(options.include), true);
return [{
get() {
return {
id: 101,
warehouse_id: 100000,
platform_code: 'CAINIAO',
shop_name: '菜鸟店铺A',
custom_name: '打印店铺A',
status: 1,
owner_id: 'owner-12345',
access_token: 'access-token',
refresh_token: 'refresh-token',
auth_random_code: 'auth-code',
printPlatform: {
platform_code: 'CAINIAO',
platform_name: '菜鸟电子面单',
},
};
},
}];
};
const result = await service.getShopList({ platform_code: 'cainiao' });
assert.equal(result.flag, 'success');
assert.equal(result.code, 200);
assert.equal(result.data.list[0].platform_code, 'CAINIAO');
assert.equal(result.data.list[0].platform_name, '菜鸟电子面单');
});
it('requestTbCainiaoStdTemplates 应使用公共模板接口且不发送 session', async () => {
const { service, calls } = createHarness();
const result = await service.requestTbCainiaoStdTemplates();
assert.equal(calls.curl, 1);
assert.equal(calls.request.url, 'https://eco.taobao.com/router/rest');
assert.equal(calls.request.options.method, 'POST');
assert.equal(calls.request.options.contentType, 'form');
assert.equal(calls.request.options.data.method, 'cainiao.cloudprint.stdtemplates.get');
assert.equal(calls.request.options.data.sign, 'TB_SIGN');
assert.equal(calls.tbSignParams.method, 'cainiao.cloudprint.stdtemplates.get');
assert.equal(Object.prototype.hasOwnProperty.call(calls.tbSignParams, 'session'), false);
assert.equal(Object.prototype.hasOwnProperty.call(calls.request.options.data, 'session'), false);
assert.deepEqual(result, {
success: true,
code: 0,
});
});
it('requestTbWaybillSearch 在 accessToken 缺失时不应发送 session 参数', async () => {
const { service, calls } = createHarness();
const result = await service.requestTbWaybillSearch({
cpCode: '',
});
assert.equal(calls.curl, 1);
assert.equal(calls.request.url, 'https://eco.taobao.com/router/rest');
assert.equal(calls.request.options.method, 'POST');
assert.equal(calls.request.options.contentType, 'form');
assert.equal(calls.request.options.data.sign, 'TB_SIGN');
assert.equal(Object.prototype.hasOwnProperty.call(calls.tbSignParams, 'session'), false);
assert.equal(Object.prototype.hasOwnProperty.call(calls.request.options.data, 'session'), false);
assert.deepEqual(result, {
success: true,
code: 0,
});
});
it('listenPlatformOauthBind 应委托平台 service 并返回监听结果', async () => {
const { service } = createHarness();
let capturedData = null;
service.service.systems.platform = {
async listenPlatformOauthBind(data) {
capturedData = data;
return {
success: true,
code: 200,
data: {
code: 'BIND001',
status: 'success',
access_token: 'ACCESS_TOKEN',
source: 'event',
},
message: '授权完成',
};
},
};
const result = await service.listenPlatformOauthBind({
business_code: 'BIND001',
long_poll: true,
});
assert.deepEqual(capturedData, {
code: 'BIND001',
longPoll: true,
timeoutMs: undefined,
});
assert.equal(result.flag, 'success');
assert.equal(result.code, 200);
assert.equal(result.data.status, 'success');
assert.equal(result.data.source, 'event');
});
it('getPrintPlatformList 应返回打印平台全量列表', async () => {
const { service, calls } = createHarness();
const result = await service.getPrintPlatformList();
assert.equal(calls.getPrintPlatformList, 1);
assert.equal(result.flag, 'success');
assert.equal(result.code, 200);
assert.equal(Array.isArray(result.data), true);
assert.equal(result.data.length, 1);
assert.deepEqual(result.data[0], {
id: 1,
code: 'CAINIAO',
name: '菜鸟电子面单',
value: 'CAINIAO',
label: '菜鸟电子面单',
platform_code: 'CAINIAO',
platform_name: '菜鸟电子面单',
platid: '1001',
});
});
});