303 lines
11 KiB
JavaScript
303 lines
11 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,
|
|
getCache: 0,
|
|
setCache: 0,
|
|
};
|
|
|
|
const ctx = {
|
|
app: {
|
|
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);
|
|
}
|
|
},
|
|
},
|
|
user: options.user || null,
|
|
model: {
|
|
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;
|
|
return options.expressSettingRows || [];
|
|
},
|
|
},
|
|
ExpressProductType: {
|
|
async findAll(query) {
|
|
calls.expressProductTypeFindAll += 1;
|
|
calls.expressProductTypeFindAllQuery = query;
|
|
return options.expressProductTypeRows || [
|
|
{ code: 'SF-EXP', name: '顺丰标准', express_code: 'SF' },
|
|
{ code: 'SF-ECON', name: '顺丰经济', express_code: 'SF' },
|
|
];
|
|
},
|
|
},
|
|
},
|
|
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 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);
|
|
|
|
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 },
|
|
]);
|
|
});
|
|
assert.deepEqual(result, cachedValue);
|
|
});
|
|
|
|
it('should delegate index.getExpressList to the express service', async () => {
|
|
const { ctx } = createExpressServiceHarness();
|
|
let serviceCalls = 0;
|
|
ctx.service = {
|
|
systems: {
|
|
express: {
|
|
async getExpressList() {
|
|
serviceCalls += 1;
|
|
return [
|
|
{ code: 'STO', name: '顺丰', value: 'STO', label: '顺丰' },
|
|
];
|
|
},
|
|
},
|
|
},
|
|
};
|
|
|
|
const methodService = new IndexMethodService(ctx);
|
|
const result = await methodService.getExpressList();
|
|
|
|
assert.equal(serviceCalls, 1);
|
|
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.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: '顺丰标准' },
|
|
]);
|
|
});
|
|
});
|