WMS_MAIN/test/app/service/systems/workbench.bigGroupTimeGate.regression.test.js
liufumingren 3d2291907e feat(workbench): 大团购打包时长按工作台打包人数分摊
- 等待秒数公式改为「大团购打包系数 x 当前波次打包数 / 当前工作台打包人数」:_packOrder 倒计时字段 pack_wait_seconds 与 _queryOrder 闸门均按人数分摊

- 新增 _countCurrentPackMembers:统计 wms_workbench_member 当前成员数,查询失败/为 0 时按 1 兜底(人数为 0 时任务已被成员全登出流程自动结束,不会出现 0 人任务)

- 闸门拉取当前打包任务仅统计进行中任务(status<2,任务已结束则不计)

- 测试:workbench.bigGroupTimeGate.regression.test.js 新增人数分摊用例(打包 2 人 1x3/2=1.5 秒、闸门 3 人 10x3/3=10 秒未到拦截/超过放行),共 13 用例全绿;ESLint 0 错误;workbench.js 语法通过

- 文档:methods/system.json 升至 0.3.183(pack_wait_seconds 描述改为人数分摊口径、big_group_pack_coefficient 描述统一),changes 新增 2 条记录,已同步库表(import+export)
2026-09-24 17:38:10 +08:00

512 lines
16 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;
},
},
WorkbenchMember: {
async count() {
// 当前工作台打包成员人数(默认 1,可配置)
return options.memberCount === undefined ? 1 : options.memberCount;
},
},
},
};
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() {
// 当前工作台绑定成员(默认 1 人,可配置)
const memberCount = options.memberCount === undefined ? 1 : options.memberCount;
return Array.from({ length: memberCount }, (_, index) => ({
id: index + 1,
user_id: 100000 + index,
user_name: `成员${index + 1}`,
}));
},
},
PackTask: {
async findOne() {
return null;
},
async findAll() {
return [];
},
async create(data) {
created.push({ ...data });
return {
id: 777,
...data,
async update() {
// mock:更新任务无操作
},
};
},
async destroy() {
return 0;
},
},
PackTaskPacker: {
async destroy() {
return 0;
},
async bulkCreate() {
// mock:写入打包人无操作
return [];
},
},
},
};
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,成员默认 1 人 → 等待秒数=1×3/1=3
assert.strictEqual(result.pack_wait_seconds, 3);
assert.ok(result.pack_start_time > 0, 'wave_scope=1 时应下发开始打包时间');
});
it('wave_scope=1 且工作台 2 人打包:等待秒数按人数分摊(1×3/2=1.5)', async () => {
const harness = createPackOrderHarness({ orderWaveScope: 1, waveScopeParam: 1, memberCount: 2 });
const result = await harness.service._packOrder(harness.packParams);
assert.strictEqual(result.pack_wait_seconds, 1.5);
assert.ok(result.pack_start_time > 0);
});
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/1=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('工作台 3 人打包时等待秒数按人数分摊(10×3/3=10 秒):未到 10 秒拦截,超过 10 秒放行', async () => {
const notReached = createQueryOrderHarness({
memberCount: 3,
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/3=10 秒,仅过去 5 秒 → 未到时 → 拦截
await assert.rejects(
() => notReached.service._queryOrder(notReached.queryParams),
error => error && error.message === '打包时长不足'
);
const reached = createQueryOrderHarness({
memberCount: 3,
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() - 12 * 1000),
create_time: new Date(Date.now() - 12 * 1000),
},
});
// 需要 10 秒,已过 12 秒 → 已到时 → 放行
const result = await reached.service._queryOrder(reached.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, '无工作台上下文不应查询打包任务');
});
});
});