WMS_MAIN/test/app/service/systems/workbench.bigGroupTimeGate.regression.test.js
liufumingren 4bf3268596 feat(workbench): 大团购打包系数与打包时长闸门,packOrder/queryOrder 响应新增 wave_scope 与倒计时字段
- 仓库设置新增 big_group_pack_coefficient(数字,默认 3,单位秒/单):store.js 默认值与归一化校验、setting.warehouse 字段元信息(type=number、min=0.1)

- workbench.queryOrder:响应 order 新增 wave_scope;当前工作台 wave_scope=1 打包任务未到「打包数x系数」秒时扫描其他波次订单返回「打包时长不足」,本波次放行,已到时不受限;闸门按 wms_pack_task.wave_scope=1 快捷判定

- workbench.packOrder:wms_pack_task 落库 wave_scope(服务端复查,非法/缺省兜底订单行值);响应新增 pack_wait_seconds(当前波次打包数x系数)与 pack_start_time(毫秒时间戳),仅 wave_scope=1 下发,其他为 0

- 迁移 20260924150000-add-wave-scope-to-pack-task.js:wms_pack_task 新增 wave_scope 列(幂等;开发与生产均已执行,生产因存在更早 pending 迁移改为等价 DDL+SequelizeMeta 记录)

- 测试:新增 workbench.bigGroupTimeGate.regression.test.js(11 用例全绿);workbench.queryOrder.performance.test.js 与基线一致(8 pass / 6 既有失败,非本次引入);ESLint 通过(workbench.js 历史类字段 parse error 为既有问题,与基线一致)

- 文档:methods/system.json 升至 0.3.181、changes 新增 2 条记录;已全量导入库表(wms_api_method_doc/wms_method_doc_meta)后重新导出,恢复 3 条库表已有但文件缺失的 setting.warehouse 前端配置方法
2026-09-24 03:16:35 +08:00

444 lines
14 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

'use strict';
const assert = require('node:assert/strict');
const Sequelize = require('sequelize');
const WorkbenchService = require('../../../../app/service/systems/workbench');
// 测试环境固定参数:仓库 100000 / 货主 1000000(与 wms-test-agent 约定一致)
const TEST_WAREHOUSE_ID = 100000;
const TEST_STORE_ID = 1000000;
const TEST_ORDER_ID = 9001;
const TEST_WAVE_ID = 5001;
const TEST_OTHER_WAVE_ID = 5002;
const TEST_BARCODE = 'SF1234567890';
const TEST_WORKBENCH_ID = 200;
// 大团购打包系数:mock 仓库配置固定为 3(秒/单)
const TEST_COEFFICIENT = 3;
/**
* 构造待处理/配送分表订单行 fixture。
* @param {Object} [overrides={}] 字段覆盖。
* @return {Object} 订单行。
*/
function buildOrderRow(overrides = {}) {
return {
id: TEST_ORDER_ID,
warehouse_id: TEST_WAREHOUSE_ID,
wave_id: TEST_WAVE_ID,
wave_no: 'W20260830001',
wave_scope: 1,
delivery_order_code: 'DO20260830001',
order_type: 1,
store_id: TEST_STORE_ID,
status: 1,
step: 1,
post_status: null,
pick_status: null,
pack_status: 'none',
intercept_status: 'none',
recheck_status: null,
outbound_status: null,
items_count: 2,
items_total: 2,
items_weight: 500,
source_platform_code: 'PDD',
logistics_name: '顺丰速运',
create_at: '2026-08-30 08:00:00',
updated_at: '2026-08-30 08:00:00',
...overrides,
};
}
/**
* 构造 _queryOrder 回归 harness(mock ctx,不访问数据库)。
* @param {Object} [options={}] 测试配置。
* @param {Object} [options.currentTask] 当前工作台进行中的打包任务行(PackTask.findOne 返回值)。
* @param {boolean} [options.withWorkbench=true] 是否携带 workbench_id(false 模拟无工作台上下文)。
* @param {Object} [options.orderRow] 订单行覆盖(wave_scope / wave_id 等)。
* @return {Object} 测试上下文。
*/
function createQueryOrderHarness(options = {}) {
const orderRow = buildOrderRow(options.orderRow || {});
const waveBatch = { wave_id: orderRow.wave_id, warehouse_id: TEST_WAREHOUSE_ID, wave_type: 1, total_orders: 99 };
const currentModel = {
async findOne() {
return orderRow;
},
async count() {
return 3;
},
};
const dispatchModel = {
async findOne() {
return null;
},
async count() {
return 4;
},
};
const itemsModel = {
async findAll() {
return [];
},
};
const packTaskCalls = { findOne: 0 };
const ctx = {
app: {
Sequelize,
config: {},
async getCacheAsync() {
return null;
},
async setCacheAsync() {
// mock:写入缓存无操作
},
},
user: { store_id: TEST_WAREHOUSE_ID },
logger: { info() {}, warn() {}, error() {} },
service: {
systems: {
deliveryOrder: {
async getStoreSubjectConfig() {
return { big_group_pack_coefficient: TEST_COEFFICIENT };
},
},
stockWarehouse: {
async getStockDetails() {
return [];
},
},
},
},
model: {
OrderExpress: {
async findOne() {
return {
order_id: TEST_ORDER_ID,
warehouse_id: TEST_WAREHOUSE_ID,
waybill_code: TEST_BARCODE,
logistics_name: '顺丰速运',
weighing_weight: 1000,
package_material_name_snapshot: '快递袋',
};
},
},
OrderDeliveryFactory: {
async getCurrentModel() {
return currentModel;
},
async getDispatchModel() {
return dispatchModel;
},
},
WaveBatch: {
async findOne() {
return waveBatch;
},
},
OrderItemsFactory: {
async getCurrentModel() {
return itemsModel;
},
async getDispatchModel() {
return itemsModel;
},
},
StoreWarehouse: {
async findOne() {
return null;
},
},
PackTask: {
async findOne(findOptions) {
packTaskCalls.findOne += 1;
if (!options.currentTask) {
return null;
}
// 模拟数据库 where 过滤:wave_scope 不匹配时视为无记录
const where = findOptions && findOptions.where;
if (where && where.wave_scope !== undefined
&& Number(where.wave_scope) !== Number(options.currentTask.wave_scope || 0)) {
return null;
}
return options.currentTask;
},
},
},
};
const service = new WorkbenchService(ctx);
const queryParams = {
barcode: TEST_BARCODE,
warehouseId: String(TEST_WAREHOUSE_ID),
...(options.withWorkbench === false ? {} : { workbench_id: TEST_WORKBENCH_ID }),
};
return { service, ctx, orderRow, packTaskCalls, queryParams };
}
/**
* 构造 _packOrder 回归 harness(散单路径 mock,不访问数据库)。
* @param {Object} [options={}] - { orderWaveScope, waveScopeParam, coefficient }
* @return {Object} 测试上下文(created 数组捕获 PackTask.create 落库数据)。
*/
function createPackOrderHarness(options = {}) {
const orderRow = buildOrderRow({
wave_id: 0,
wave_no: '',
wave_scope: options.orderWaveScope === undefined ? 1 : options.orderWaveScope,
});
const created = [];
const orderModel = {
async findOne() {
return orderRow;
},
async update() {
return [ 1 ];
},
};
const ctx = {
app: {
Sequelize,
config: {},
async getCacheAsync() {
return null;
},
async setCacheAsync() {
// mock:写入缓存无操作
},
async delCacheAsync() {
// mock:删除缓存无操作
},
},
logger: { info() {}, warn() {}, error() {} },
service: {
systems: {
deliveryOrder: {
async getStoreSubjectConfig() {
return { big_group_pack_coefficient: options.coefficient === undefined ? TEST_COEFFICIENT : options.coefficient };
},
},
},
systemMethods: {
order: {
wave: {
async bumpConfirmPrintUnclaimedWaveVersion() {
// mock:统计版本号递增无操作
},
},
},
},
},
model: {
OrderDeliveryFactory: {
async getCurrentModel() {
return orderModel;
},
async getDispatchModel() {
return orderModel;
},
},
WaveBatch: {
async findOne() {
return null;
},
},
OrderExpress: {
async findOne() {
return null;
},
},
Workbench: {
async findByPk() {
return { name: '打包台1', device_ids: null, token: 'mock-token' };
},
},
WorkbenchMember: {
async findAll() {
return [];
},
},
PackTask: {
async findOne() {
return null;
},
async findAll() {
return [];
},
async create(data) {
created.push({ ...data });
return { id: 777, ...data };
},
async destroy() {
return 0;
},
},
PackTaskPacker: {
async destroy() {
return 0;
},
},
},
};
const service = new WorkbenchService(ctx);
const packParams = {
delivery_order_code: orderRow.delivery_order_code,
warehouse_id: TEST_WAREHOUSE_ID,
workbench_id: TEST_WORKBENCH_ID,
...(options.waveScopeParam === undefined ? {} : { wave_scope: options.waveScopeParam }),
};
return { service, ctx, orderRow, created, packParams };
}
describe('workbench 大团购打包系数回归(wave_scope 落库 / 倒计时下发 / 查询阀门)', () => {
describe('1. queryOrder 响应带波次类型(order.wave_scope)', () => {
it('大团购订单(wave_scope=1)响应返回 order.wave_scope=1', async () => {
const harness = createQueryOrderHarness({ orderRow: { wave_scope: 1 } });
const result = await harness.service._queryOrder(harness.queryParams);
assert.strictEqual(result.order.wave_scope, 1);
});
it('散单波次订单(wave_scope=2)响应返回 order.wave_scope=2', async () => {
const harness = createQueryOrderHarness({ orderRow: { wave_scope: 2 } });
const result = await harness.service._queryOrder(harness.queryParams);
assert.strictEqual(result.order.wave_scope, 2);
});
});
describe('2. packOrder 信息写入 wms_pack_task(wave_scope 落库)与倒计时字段下发', () => {
it('wave_scope=1:PackTask.create 落库 wave_scope=1,并下发 pack_wait_seconds=打包数×系数 与 pack_start_time>0', async () => {
const harness = createPackOrderHarness({ orderWaveScope: 1, waveScopeParam: 1 });
const result = await harness.service._packOrder(harness.packParams);
assert.strictEqual(harness.created.length, 1, '应创建一条打包任务');
assert.strictEqual(harness.created[0].wave_scope, 1, 'wave_scope=1 应写入打包任务');
// 散单打包数=1,系数=3 → 等待秒数=3
assert.strictEqual(result.pack_wait_seconds, 3);
assert.ok(result.pack_start_time > 0, 'wave_scope=1 时应下发开始打包时间');
});
it('未上报 wave_scope:兜底订单行 wave_scope=1 落库,并下发倒计时字段', async () => {
const harness = createPackOrderHarness({ orderWaveScope: 1 });
const result = await harness.service._packOrder(harness.packParams);
assert.strictEqual(harness.created[0].wave_scope, 1, '缺省时应兜底订单行 wave_scope=1 落库');
assert.strictEqual(result.pack_wait_seconds, 3);
assert.ok(result.pack_start_time > 0);
});
it('wave_scope=2(非大团购):落库 wave_scope=2,倒计时字段一律为 0', async () => {
const harness = createPackOrderHarness({ orderWaveScope: 2, waveScopeParam: 2 });
const result = await harness.service._packOrder(harness.packParams);
assert.strictEqual(harness.created[0].wave_scope, 2);
assert.strictEqual(result.pack_wait_seconds, 0);
assert.strictEqual(result.pack_start_time, 0);
});
});
describe('3. queryOrder 大团购打包时长阀门(wave_scope=1 任务限制,其他不限制)', () => {
it('wave_scope=1 任务未到时 + 查询订单非本波次 → 抛「打包时长不足」', async () => {
const harness = createQueryOrderHarness({
orderRow: { wave_scope: 1, wave_id: TEST_WAVE_ID },
currentTask: {
id: 1,
wave_scope: 1,
wave_id: TEST_OTHER_WAVE_ID,
pack_quantity: 10,
start_time: new Date(Date.now() - 5 * 1000),
create_time: new Date(Date.now() - 5 * 1000),
},
});
// 需要 10×3=30 秒,仅过去 5 秒 → 未到时 → 不同波次拦截
await assert.rejects(
() => harness.service._queryOrder(harness.queryParams),
error => error && error.message === '打包时长不足'
);
});
it('wave_scope=1 任务未到时 + 查询订单为本波次 → 正常返回信息', async () => {
const harness = createQueryOrderHarness({
orderRow: { wave_scope: 1, wave_id: TEST_OTHER_WAVE_ID },
currentTask: {
id: 1,
wave_scope: 1,
wave_id: TEST_OTHER_WAVE_ID,
pack_quantity: 10,
start_time: new Date(Date.now() - 5 * 1000),
create_time: new Date(Date.now() - 5 * 1000),
},
});
const result = await harness.service._queryOrder(harness.queryParams);
assert.strictEqual(result.order.wave_id, TEST_OTHER_WAVE_ID);
assert.strictEqual(result.order.wave_scope, 1);
});
it('wave_scope=1 任务已到时 + 查询订单非本波次 → 正常返回(不限制)', async () => {
const harness = createQueryOrderHarness({
orderRow: { wave_scope: 1, wave_id: TEST_WAVE_ID },
currentTask: {
id: 1,
wave_scope: 1,
wave_id: TEST_OTHER_WAVE_ID,
pack_quantity: 10,
start_time: new Date(Date.now() - 60 * 1000),
create_time: new Date(Date.now() - 60 * 1000),
},
});
// 需要 30 秒,已过 60 秒 → 已到时 → 不拦截
const result = await harness.service._queryOrder(harness.queryParams);
assert.strictEqual(result.order.wave_id, TEST_WAVE_ID);
});
it('当前任务 wave_scope≠1(散单任务)→ 不限制(其他不限制)', async () => {
const harness = createQueryOrderHarness({
orderRow: { wave_scope: 1, wave_id: TEST_WAVE_ID },
currentTask: {
id: 1,
wave_scope: 2,
wave_id: TEST_OTHER_WAVE_ID,
pack_quantity: 10,
start_time: new Date(Date.now() - 5 * 1000),
create_time: new Date(Date.now() - 5 * 1000),
},
});
// 任务 wave_scope=2 不匹配阀门 where.wave_scope=1 → 无匹配任务 → 不拦截
const result = await harness.service._queryOrder(harness.queryParams);
assert.strictEqual(result.order.wave_id, TEST_WAVE_ID);
assert.strictEqual(harness.packTaskCalls.findOne, 1);
});
it('无进行中的 wave_scope=1 任务 → 不限制', async () => {
const harness = createQueryOrderHarness({ orderRow: { wave_scope: 1, wave_id: TEST_WAVE_ID } });
const result = await harness.service._queryOrder(harness.queryParams);
assert.strictEqual(result.order.wave_id, TEST_WAVE_ID);
assert.strictEqual(harness.packTaskCalls.findOne, 1);
});
it('无 workbench_id 上下文 → 不触发阀门查询', async () => {
const harness = createQueryOrderHarness({
withWorkbench: false,
orderRow: { wave_scope: 1, wave_id: TEST_WAVE_ID },
});
const result = await harness.service._queryOrder(harness.queryParams);
assert.strictEqual(result.order.wave_id, TEST_WAVE_ID);
assert.strictEqual(harness.packTaskCalls.findOne, 0, '无工作台上下文不应查询打包任务');
});
});
});