WMS_MAIN/test/wave_first_pool_merge_regression_20260908.cjs
liufumingren d73c66c2f3 feat: 小团购PDA抓取跨池同结构合并
- 小团购(pickMode=1)抓取新增跨池同结构合并工序,第一池出现的结构按全池过筛口径合并今日同结构订单一并建波,修复订单池今日/今日前分割导致同结构订单被拆散后的 1 单 1 波次问题(生产订单 11103)
- 三重门控:仅小团购+第一池非空+max_same_structure 有效(null/999 跳过维持现状),大团购与后台抓取不覆盖
- 新增 merged_order_count 统计字段;同步 methods 文档与变更记录
- 回归 26 用例全部通过
2026-09-08 21:38:53 +08:00

808 lines
34 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';
/**
* 回归测试:小团购 PDA 抓取跨池同结构合并(mergeWaveStrategyFirstPoolSameStructureOrders)
*
* 测试方式:纯函数级回归。mock ctx.model.query / OrderDeliveryFactory / 事务对象,
* 不执行任何数据库与 Redis 写操作;测试仓库固定为 100000(仅内存脚本使用)。
*
* 运行:node test/wave_first_pool_merge_regression_20260908.cjs
*
* 覆盖回归点:
* 1. 小团购 + 团购策略 + max_same_structure 有效 + 第一池非空:两池同结构合并为单波次
* 2. require_same_express=1:仅并入「结构+同快递」组合,快递 COALESCE 口径与候选 SQL 一致
* 3. max_same_structure null/999:不合并(行为与改动前一致)
* 4. pickMode=5(大团购):不合并
* 5. 管理后台 executeWaveStrategyDirectFetch / waveStrategyFetchAdmin:不经过合并链路
* 6. 第一池为空(直接抓全池):不合并
* 7. 并发先占:建波复筛只锁 wave_id=0 订单,total_orders 回填正确
* 8. group_batch_max_orders/box_limit 多组:选组顺序、建波数量、merged_order_count 正确
*/
const fs = require('node:fs');
const path = require('node:path');
const { assert, suite, run } = require('./support/mini_test_framework.cjs');
const Sequelize = require('sequelize');
const WaveService = require('../app/service/systemMethods/order/wave');
const WAREHOUSE_ID = 100000; // 固定测试仓库 ID
const STRATEGY_ID = 88; // 内存策略 ID(不落库)
const WAVE_SOURCE_FILE = path.join(__dirname, '..', 'app', 'service', 'systemMethods', 'order', 'wave.js');
// 与 wave.js 候选 SQL 中 expressExpr 完全一致的快递口径(用于断言两处 SQL 一致)
const EXPRESS_EXPR = alias => `COALESCE(NULLIF(TRIM(COALESCE(${alias}.sys_logistics_code, '')), ''), NULLIF(TRIM(COALESCE(${alias}.logistics_code, '')), ''), TRIM(COALESCE(${alias}.logistics_name, '')))`;
function orderRow(id, itemsHash, extra = {}) {
return {
id,
items_hash: itemsHash,
items: `items-${itemsHash}`,
logistics_name: '',
sys_logistics_code: '',
logistics_code: '',
items_count: 1,
items_total: 1,
...extra,
};
}
function buildStrategyRow(overrides = {}) {
return {
strategy_type: 2,
min_same_structure: 1,
max_same_structure: 5,
require_same_express: 0,
group_batch_max_orders: 1,
...overrides,
};
}
function buildPlan(pickMode, extra = {}) {
return {
warehouse_id: WAREHOUSE_ID,
strategy_id: STRATEGY_ID,
pick_mode: pickMode,
box_limit: 1,
strategy_type: 2,
operator: { operator_id: 7, operator_name: '测试员' },
...extra,
};
}
/**
* 构建 mock ctx 与 service 实例。
* 候选查询(含 wms_order_wave_strategy_match)按 createdBefore 区分第一池/第二池;
* 合并查询(含 IN (:structureKeys))返回 mergedRows。
*
* @param {Object} [options={}] 构建配置(firstPoolRows/secondPoolRows/mergedRows/transaction)。
* @return {Object} harness 对象(service/queryCalls/transactionToken/orderModel)。
*/
function buildHarness(options = {}) {
const queryCalls = [];
const firstPoolRows = options.firstPoolRows || [];
const secondPoolRows = options.secondPoolRows || [];
const mergedRows = options.mergedRows || [];
const transactionToken = options.transaction || { tx: 'tx-token' };
const orderModel = {
getTableName: () => 'wms_order_pending_100000',
};
const model = {
QueryTypes: { SELECT: 'SELECT' },
OrderDeliveryFactory: {
getCurrentModel: async () => orderModel,
},
async query(sql, params) {
queryCalls.push({ sql, params });
if (sql.includes('wms_order_wave_strategy_match')) {
const createdBefore = params && params.replacements ? params.replacements.createdBefore : null;
return createdBefore ? firstPoolRows : secondPoolRows;
}
if (sql.includes('IN (:structureKeys)')) {
return mergedRows;
}
throw new Error(`未预期的 SQL: ${sql.slice(0, 120)}`);
},
async transaction() {
return { commit: async () => {}, rollback: async () => {}, LOCK: { UPDATE: 'UPDATE' } };
},
};
const ctx = {
user: { store_id: WAREHOUSE_ID },
logger: { info() {}, warn() {}, error() {} },
app: { Sequelize },
service: {},
model,
};
const service = new WaveService(ctx);
service.ctx = ctx;
// 非目标协作方法打桩,避免触库
service.ensureNoActiveWavePickTaskForOperator = async () => {};
service.resolveWaveStrategyFetchWavePrefix = async () => ({ wavePrefix: 'T', source: 'strategy' });
service.batchCreateOrderOperationLogs = async () => {};
return { service, queryCalls, transactionToken, orderModel };
}
/**
* 打桩建波方法并记录每次建波的订单集合。
*
* @param {Object} service WaveService 实例。
* @return {Array<Object>} 建波调用记录数组。
*/
function recordWaveCreations(service) {
const creations = [];
let waveSeq = 900;
service.createWaveBatchByOrderIdsInTransaction = async params => {
waveSeq += 1;
const selected = [ ...params.orderIds ].sort((a, b) => a - b);
creations.push({
warehouseId: params.warehouseId,
orderIds: selected,
waveType: params.waveType,
source: params.source,
});
return { waveId: waveSeq, waveNo: `T${waveSeq}`, selectedOrderIds: selected };
};
return creations;
}
/**
* 禁止合并:合并方法被调用即抛错,用于验证「不触发合并」的路径。
*
* @param {Object} service WaveService 实例。
* @return {void}
*/
function forbidMerge(service) {
service.mergeWaveStrategyFirstPoolSameStructureOrders = async () => {
throw new Error('合并不应在该链路被调用');
};
}
// ---------------------------------------------------------------------------
// A. 合并函数门控与合并口径(纯函数级)
// ---------------------------------------------------------------------------
const suiteA = suite('A. mergeWaveStrategyFirstPoolSameStructureOrders 门控与合并口径', t => {
t('A1 pickMode=5(大团购)不合并且不查询', async () => {
const h = buildHarness();
const candidateRows = [ orderRow(101, 'HASH-A') ];
const result = await h.service.mergeWaveStrategyFirstPoolSameStructureOrders({
warehouseId: WAREHOUSE_ID,
strategyRow: buildStrategyRow(),
candidateRows,
effectiveGroupedRows: h.service.groupWaveStrategyFetchCandidateOrdersByStructure(candidateRows),
candidatePoolStage: 'first',
pickMode: 5,
requireSameExpress: false,
transaction: h.transactionToken,
});
assert.strictEqual(result, null);
assert.strictEqual(h.queryCalls.length, 0);
});
t('A2 第二池阶段(第一池为空)不合并且不查询', async () => {
const h = buildHarness();
const candidateRows = [ orderRow(101, 'HASH-A') ];
const result = await h.service.mergeWaveStrategyFirstPoolSameStructureOrders({
warehouseId: WAREHOUSE_ID,
strategyRow: buildStrategyRow(),
candidateRows,
effectiveGroupedRows: h.service.groupWaveStrategyFetchCandidateOrdersByStructure(candidateRows),
candidatePoolStage: 'second',
pickMode: 1,
requireSameExpress: false,
transaction: h.transactionToken,
});
assert.strictEqual(result, null);
assert.strictEqual(h.queryCalls.length, 0);
});
t('A3 max_same_structure=null 不合并且不查询', async () => {
const h = buildHarness();
const candidateRows = [ orderRow(101, 'HASH-A') ];
const result = await h.service.mergeWaveStrategyFirstPoolSameStructureOrders({
warehouseId: WAREHOUSE_ID,
strategyRow: buildStrategyRow({ max_same_structure: null }),
candidateRows,
effectiveGroupedRows: h.service.groupWaveStrategyFetchCandidateOrdersByStructure(candidateRows),
candidatePoolStage: 'first',
pickMode: 1,
requireSameExpress: false,
transaction: h.transactionToken,
});
assert.strictEqual(result, null);
assert.strictEqual(h.queryCalls.length, 0);
});
t('A4 max_same_structure=999 不合并且不查询', async () => {
const h = buildHarness();
const candidateRows = [ orderRow(101, 'HASH-A') ];
const result = await h.service.mergeWaveStrategyFirstPoolSameStructureOrders({
warehouseId: WAREHOUSE_ID,
strategyRow: buildStrategyRow({ max_same_structure: 999 }),
candidateRows,
effectiveGroupedRows: h.service.groupWaveStrategyFetchCandidateOrdersByStructure(candidateRows),
candidatePoolStage: 'first',
pickMode: 1,
requireSameExpress: false,
transaction: h.transactionToken,
});
assert.strictEqual(result, null);
assert.strictEqual(h.queryCalls.length, 0);
});
t('A5 门控通过:全池同结构查询口径正确(不限策略/不含池边界/无计数门槛)', async () => {
const h = buildHarness({
mergedRows: [ orderRow(101, 'HASH-A'), orderRow(102, 'HASH-A'), orderRow(103, 'HASH-A') ],
});
const candidateRows = [ orderRow(101, 'HASH-A') ];
const result = await h.service.mergeWaveStrategyFirstPoolSameStructureOrders({
warehouseId: WAREHOUSE_ID,
strategyRow: buildStrategyRow({ max_same_structure: 5 }),
candidateRows,
effectiveGroupedRows: h.service.groupWaveStrategyFetchCandidateOrdersByStructure(candidateRows),
candidatePoolStage: 'first',
pickMode: 1,
requireSameExpress: false,
transaction: h.transactionToken,
});
assert.deepStrictEqual(result.map(row => row.id), [ 101, 102, 103 ]);
assert.strictEqual(h.queryCalls.length, 1);
const mergeCall = h.queryCalls[0];
assert.strictEqual(mergeCall.sql.includes('IN (:structureKeys)'), true);
// 全池口径:不限策略匹配、不含池边界 create_at、无同结构计数门槛
assert.strictEqual(mergeCall.sql.includes('wms_order_wave_strategy_match'), false);
assert.strictEqual(mergeCall.sql.includes('create_at'), false);
assert.strictEqual(mergeCall.sql.includes('same_structure_count'), false);
// 未要求同快递时不携带快递口径
assert.strictEqual(mergeCall.sql.includes('COALESCE'), false);
assert.strictEqual(mergeCall.params.replacements.warehouseId, WAREHOUSE_ID);
assert.deepStrictEqual(mergeCall.params.replacements.structureKeys, [ 'HASH-A' ]);
// 合并查询与建波共用同一事务
assert.strictEqual(mergeCall.params.transaction, h.transactionToken);
});
t('A6 合并无新增订单(全池订单均已在一池)时返回 null', async () => {
const h = buildHarness({ mergedRows: [ orderRow(101, 'HASH-A') ] });
const candidateRows = [ orderRow(101, 'HASH-A') ];
const result = await h.service.mergeWaveStrategyFirstPoolSameStructureOrders({
warehouseId: WAREHOUSE_ID,
strategyRow: buildStrategyRow(),
candidateRows,
effectiveGroupedRows: h.service.groupWaveStrategyFetchCandidateOrdersByStructure(candidateRows),
candidatePoolStage: 'first',
pickMode: 1,
requireSameExpress: false,
transaction: h.transactionToken,
});
assert.strictEqual(result, null);
});
t('A7 合并结果按 id 去重并升序', async () => {
const h = buildHarness({
mergedRows: [ orderRow(103, 'HASH-A'), orderRow(101, 'HASH-A'), orderRow(102, 'HASH-A') ],
});
const candidateRows = [ orderRow(101, 'HASH-A') ];
const result = await h.service.mergeWaveStrategyFirstPoolSameStructureOrders({
warehouseId: WAREHOUSE_ID,
strategyRow: buildStrategyRow(),
candidateRows,
effectiveGroupedRows: h.service.groupWaveStrategyFetchCandidateOrdersByStructure(candidateRows),
candidatePoolStage: 'first',
pickMode: 1,
requireSameExpress: false,
transaction: h.transactionToken,
});
assert.deepStrictEqual(result.map(row => row.id), [ 101, 102, 103 ]);
});
});
// ---------------------------------------------------------------------------
// B. require_same_express=1 快递口径
// ---------------------------------------------------------------------------
const suiteB = suite('B. require_same_express=1 快递口径', t => {
t('B1 仅并入「结构+同快递」组合,快递口径与候选 SQL 一致', async () => {
const h = buildHarness({
mergedRows: [ orderRow(101, 'HASH-A', { sys_logistics_code: 'SF' }), orderRow(102, 'HASH-A', { sys_logistics_code: 'SF' }) ],
});
const candidateRows = [ orderRow(101, 'HASH-A', { sys_logistics_code: 'SF' }) ];
const result = await h.service.mergeWaveStrategyFirstPoolSameStructureOrders({
warehouseId: WAREHOUSE_ID,
strategyRow: buildStrategyRow({ require_same_express: 1 }),
candidateRows,
effectiveGroupedRows: h.service.groupWaveStrategyFetchCandidateOrdersByStructure(candidateRows),
candidatePoolStage: 'first',
pickMode: 1,
requireSameExpress: true,
transaction: h.transactionToken,
});
assert.deepStrictEqual(result.map(row => row.id), [ 101, 102 ]);
const mergeCall = h.queryCalls[0];
// 合并 SQL 携带与候选 SQL 完全一致的 COALESCE 快递口径(alias o)
assert.strictEqual(mergeCall.sql.includes(EXPRESS_EXPR('o')), true);
assert.strictEqual(mergeCall.sql.includes('IN (:expressKeys)'), true);
assert.deepStrictEqual(mergeCall.params.replacements.expressKeys, [ 'SF' ]);
assert.deepStrictEqual(mergeCall.params.replacements.structureKeys, [ 'HASH-A' ]);
});
t('B2 第一池同结构多快递时只取最大快递组的快递 key(其他快递不并入最终波次)', async () => {
const h = buildHarness({
firstPoolRows: [
orderRow(101, 'HASH-A', { sys_logistics_code: 'SF' }),
orderRow(102, 'HASH-A', { sys_logistics_code: 'YT' }),
],
mergedRows: [
orderRow(101, 'HASH-A', { sys_logistics_code: 'SF' }),
orderRow(103, 'HASH-A', { sys_logistics_code: 'SF' }),
],
});
const creations = recordWaveCreations(h.service);
const result = await h.service.autoPopulateWaveStrategyFetchSelections({
plan: buildPlan(1),
strategyRow: buildStrategyRow({ require_same_express: 1 }),
waveBatchSource: 2,
transaction: h.transactionToken,
});
// 合并后再按快递筛选,仅同快递(SF)订单入波,其他快递(YT)不并入
assert.deepStrictEqual(result.selected_order_ids, [ 101, 103 ]);
assert.strictEqual(result.merged_order_count, 1);
assert.strictEqual(creations.length, 1);
assert.deepStrictEqual(creations[0].orderIds, [ 101, 103 ]);
const mergeCall = h.queryCalls.find(call => call.sql.includes('IN (:structureKeys)'));
assert.deepStrictEqual(mergeCall.params.replacements.expressKeys, [ 'SF' ]);
assert.deepStrictEqual(mergeCall.params.replacements.structureKeys, [ 'HASH-A' ]);
});
t('B3 快递 key 优先级:sys_logistics_code > logistics_code > logistics_name(与 COALESCE 一致)', () => {
const h = buildHarness();
assert.strictEqual(
h.service.getWaveStrategyQuickScanExpressKey({ sys_logistics_code: 'A', logistics_code: 'B', logistics_name: 'C' }),
'A'
);
assert.strictEqual(
h.service.getWaveStrategyQuickScanExpressKey({ sys_logistics_code: '', logistics_code: 'B', logistics_name: 'C' }),
'B'
);
assert.strictEqual(
h.service.getWaveStrategyQuickScanExpressKey({ sys_logistics_code: '', logistics_code: '', logistics_name: 'C' }),
'C'
);
assert.strictEqual(
h.service.getWaveStrategyQuickScanExpressKey({ sys_logistics_code: '', logistics_code: '', logistics_name: '' }),
''
);
});
t('B4 组内订单快递 key 为空时不合并且不查询', async () => {
const h = buildHarness();
const candidateRows = [ orderRow(101, 'HASH-A') ];
const result = await h.service.mergeWaveStrategyFirstPoolSameStructureOrders({
warehouseId: WAREHOUSE_ID,
strategyRow: buildStrategyRow({ require_same_express: 1 }),
candidateRows,
effectiveGroupedRows: h.service.groupWaveStrategyFetchCandidateOrdersByStructure(candidateRows),
candidatePoolStage: 'first',
pickMode: 1,
requireSameExpress: true,
transaction: h.transactionToken,
});
assert.strictEqual(result, null);
assert.strictEqual(h.queryCalls.length, 0);
});
});
// ---------------------------------------------------------------------------
// C. autoPopulateWaveStrategyFetchSelections 集成(回归点 1/2/3/4/6/8)
// ---------------------------------------------------------------------------
const suiteC = suite('C. autoPopulateWaveStrategyFetchSelections 集成', t => {
t('C1 回归点1:第一池 1 条 + 今日同结构多条 → 合并后单波次包含两池全部订单', async () => {
const h = buildHarness({
firstPoolRows: [ orderRow(101, 'HASH-A') ],
mergedRows: [
orderRow(101, 'HASH-A'),
orderRow(102, 'HASH-A'),
orderRow(103, 'HASH-A'),
orderRow(104, 'HASH-A'),
],
});
const creations = recordWaveCreations(h.service);
const result = await h.service.autoPopulateWaveStrategyFetchSelections({
plan: buildPlan(1),
strategyRow: buildStrategyRow(),
waveBatchSource: 2,
transaction: h.transactionToken,
});
assert.deepStrictEqual(result.selected_wave_ids, [ 901 ]);
assert.deepStrictEqual(result.selected_order_ids, [ 101, 102, 103, 104 ]);
assert.strictEqual(result.merged_order_count, 3);
assert.strictEqual(result.candidate_pool_stage, 'first');
assert.strictEqual(result.first_pool_candidate_count, 1);
assert.strictEqual(creations.length, 1);
assert.deepStrictEqual(creations[0].orderIds, [ 101, 102, 103, 104 ]);
// 仅一次候选查询(第一池非空不查第二池)+ 一次合并查询
const candidateCalls = h.queryCalls.filter(call => call.sql.includes('wms_order_wave_strategy_match'));
const mergeCalls = h.queryCalls.filter(call => call.sql.includes('IN (:structureKeys)'));
assert.strictEqual(candidateCalls.length, 1);
assert.strictEqual(mergeCalls.length, 1);
assert.strictEqual(candidateCalls[0].params.replacements.createdBefore instanceof Date, true);
});
t('C2 回归点2:require_same_express=1 时同快递全池并入,候选 SQL 与合并 SQL 快递口径一致', async () => {
const h = buildHarness({
firstPoolRows: [
orderRow(101, 'HASH-A', { sys_logistics_code: 'SF' }),
orderRow(102, 'HASH-A', { sys_logistics_code: 'SF' }),
],
mergedRows: [
orderRow(101, 'HASH-A', { sys_logistics_code: 'SF' }),
orderRow(102, 'HASH-A', { sys_logistics_code: 'SF' }),
orderRow(103, 'HASH-A', { sys_logistics_code: 'SF' }),
orderRow(104, 'HASH-A', { sys_logistics_code: 'SF' }),
],
});
const creations = recordWaveCreations(h.service);
const strategyRow = buildStrategyRow({ require_same_express: 1 });
const result = await h.service.autoPopulateWaveStrategyFetchSelections({
plan: buildPlan(1),
strategyRow,
waveBatchSource: 2,
transaction: h.transactionToken,
});
assert.deepStrictEqual(result.selected_order_ids, [ 101, 102, 103, 104 ]);
assert.strictEqual(result.merged_order_count, 2);
assert.strictEqual(creations.length, 1);
const candidateCall = h.queryCalls.find(call => call.sql.includes('wms_order_wave_strategy_match'));
const mergeCall = h.queryCalls.find(call => call.sql.includes('IN (:structureKeys)'));
// 候选 SQL 的 src 计数与 o 连接条件均使用同一 COALESCE 快递口径
assert.strictEqual(candidateCall.sql.includes(EXPRESS_EXPR('src')), true);
assert.strictEqual(candidateCall.sql.includes(EXPRESS_EXPR('o')), true);
// 合并 SQL 使用与候选一致的 COALESCE 快递口径(alias o)
assert.strictEqual(mergeCall.sql.includes(EXPRESS_EXPR('o')), true);
assert.deepStrictEqual(mergeCall.params.replacements.expressKeys, [ 'SF' ]);
});
t('C3 回归点3:max_same_structure=999 不合并,行为与改动前一致', async () => {
const h = buildHarness({ firstPoolRows: [ orderRow(101, 'HASH-A') ] });
const creations = recordWaveCreations(h.service);
const result = await h.service.autoPopulateWaveStrategyFetchSelections({
plan: buildPlan(1),
strategyRow: buildStrategyRow({ max_same_structure: 999 }),
waveBatchSource: 2,
transaction: h.transactionToken,
});
assert.strictEqual(result.merged_order_count, 0);
assert.deepStrictEqual(result.selected_order_ids, [ 101 ]);
assert.strictEqual(creations.length, 1);
// 未执行任何合并查询
assert.strictEqual(h.queryCalls.some(call => call.sql.includes('IN (:structureKeys)')), false);
});
t('C4 回归点3:max_same_structure=null 不合并,行为与改动前一致', async () => {
const h = buildHarness({ firstPoolRows: [ orderRow(101, 'HASH-A') ] });
const creations = recordWaveCreations(h.service);
const result = await h.service.autoPopulateWaveStrategyFetchSelections({
plan: buildPlan(1),
strategyRow: buildStrategyRow({ max_same_structure: null }),
waveBatchSource: 2,
transaction: h.transactionToken,
});
assert.strictEqual(result.merged_order_count, 0);
assert.deepStrictEqual(result.selected_order_ids, [ 101 ]);
assert.strictEqual(creations.length, 1);
assert.strictEqual(h.queryCalls.some(call => call.sql.includes('IN (:structureKeys)')), false);
});
t('C5 回归点4:pickMode=5(大团购)不合并', async () => {
const h = buildHarness({ firstPoolRows: [ orderRow(101, 'HASH-A') ] });
const creations = recordWaveCreations(h.service);
const result = await h.service.autoPopulateWaveStrategyFetchSelections({
plan: buildPlan(5),
strategyRow: buildStrategyRow(),
waveBatchSource: 2,
transaction: h.transactionToken,
});
assert.strictEqual(result.merged_order_count, 0);
assert.deepStrictEqual(result.selected_order_ids, [ 101 ]);
assert.strictEqual(creations.length, 1);
assert.strictEqual(h.queryCalls.some(call => call.sql.includes('IN (:structureKeys)')), false);
});
t('C6 回归点6:第一池为空直接抓全池,不合并且查询两次(一池+全池)', async () => {
const h = buildHarness({
firstPoolRows: [],
secondPoolRows: [ orderRow(101, 'HASH-A'), orderRow(102, 'HASH-A') ],
});
const creations = recordWaveCreations(h.service);
const result = await h.service.autoPopulateWaveStrategyFetchSelections({
plan: buildPlan(1),
strategyRow: buildStrategyRow(),
waveBatchSource: 2,
transaction: h.transactionToken,
});
assert.strictEqual(result.candidate_pool_stage, 'second');
assert.strictEqual(result.merged_order_count, 0);
assert.deepStrictEqual(result.selected_order_ids, [ 101, 102 ]);
assert.strictEqual(creations.length, 1);
assert.strictEqual(h.queryCalls.some(call => call.sql.includes('IN (:structureKeys)')), false);
const candidateCalls = h.queryCalls.filter(call => call.sql.includes('wms_order_wave_strategy_match'));
assert.strictEqual(candidateCalls.length, 2);
assert.strictEqual(candidateCalls[0].params.replacements.createdBefore instanceof Date, true);
assert.strictEqual(candidateCalls[1].params.replacements.createdBefore, null);
});
t('C7 回归点8:group_batch_max_orders=2 多组场景,选组顺序/建波数量/merged_order_count 正确', async () => {
const h = buildHarness({
firstPoolRows: [ orderRow(101, 'HASH-A'), orderRow(201, 'HASH-B'), orderRow(301, 'HASH-C') ],
mergedRows: [
orderRow(101, 'HASH-A'),
orderRow(102, 'HASH-A'),
orderRow(201, 'HASH-B'),
orderRow(202, 'HASH-B'),
orderRow(301, 'HASH-C'),
],
});
const creations = recordWaveCreations(h.service);
const result = await h.service.autoPopulateWaveStrategyFetchSelections({
plan: buildPlan(1, { box_limit: 2 }),
strategyRow: buildStrategyRow({ group_batch_max_orders: 2 }),
waveBatchSource: 2,
transaction: h.transactionToken,
});
assert.strictEqual(result.merged_order_count, 2);
assert.strictEqual(creations.length, 2);
// 按组内最小订单号选组:HASH-A(101) 与 HASH-B(201) 入选,HASH-C(301) 不入选
assert.deepStrictEqual(creations[0].orderIds, [ 101, 102 ]);
assert.deepStrictEqual(creations[1].orderIds, [ 201, 202 ]);
assert.deepStrictEqual(result.selected_order_ids, [ 101, 102, 201, 202 ]);
assert.deepStrictEqual(result.selected_wave_ids, [ 901, 902 ]);
});
t('C8 合并无新增订单(该结构全池订单均在第一池)时不合并,结果与改动前一致', async () => {
const h = buildHarness({
firstPoolRows: [ orderRow(101, 'HASH-A'), orderRow(102, 'HASH-A') ],
mergedRows: [ orderRow(101, 'HASH-A'), orderRow(102, 'HASH-A') ],
});
const creations = recordWaveCreations(h.service);
const result = await h.service.autoPopulateWaveStrategyFetchSelections({
plan: buildPlan(1),
strategyRow: buildStrategyRow(),
waveBatchSource: 2,
transaction: h.transactionToken,
});
assert.strictEqual(result.merged_order_count, 0);
assert.deepStrictEqual(result.selected_order_ids, [ 101, 102 ]);
assert.strictEqual(creations.length, 1);
});
});
// ---------------------------------------------------------------------------
// D. 建波复筛与 total_orders 回填(回归点 7)
// ---------------------------------------------------------------------------
function buildWaveCreationHarness(options = {}) {
const queryCalls = [];
const findAllCalls = [];
const updateCalls = [];
const waveReadyCalls = [];
const lockRows = options.lockRows || [];
const grabbedRows = options.grabbedRows || [];
const transaction = { LOCK: { UPDATE: 'UPDATE' } };
const orderModel = {
async findAll(queryOptions) {
findAllCalls.push(queryOptions);
return findAllCalls.length === 1 ? lockRows : grabbedRows;
},
async update(payload, queryOptions) {
updateCalls.push({ payload, queryOptions });
},
};
const model = {
QueryTypes: { SELECT: 'SELECT' },
OrderDeliveryFactory: {
getCurrentModel: async () => orderModel,
},
async query(sql, params) {
queryCalls.push({ sql, params });
return [];
},
WaveBatch: { update: async () => {} },
};
const ctx = {
user: { store_id: WAREHOUSE_ID },
logger: { info() {}, warn() {}, error() {} },
app: { Sequelize },
service: {},
model,
};
const service = new WaveService(ctx);
service.ctx = ctx;
service.createWaveBatchReady = async payload => {
waveReadyCalls.push(payload);
return { waveId: 777, waveNo: 'T777' };
};
service.rebuildOrderWaveIndex = async () => {};
return { service, queryCalls, findAllCalls, updateCalls, waveReadyCalls, transaction };
}
const suiteD = suite('D. createWaveBatchByOrderIdsInTransaction 并发复筛与回填', t => {
t('D1 合并带出订单被先占:锁只命中 wave_id=0 订单,波次 total_orders 按可用数建波', async () => {
const occupied = { id: 102, wave_id: 999, items_hash: 'HASH-A', items: 'x' };
const h = buildWaveCreationHarness({
lockRows: [
{ id: 101, wave_id: 0, items_hash: 'HASH-A', items: 'x' },
{ id: 103, wave_id: 0, items_hash: 'HASH-A', items: 'x' },
],
grabbedRows: [
{ id: 101, wave_id: 0, items_hash: 'HASH-A', items: 'x' },
{ id: 103, wave_id: 0, items_hash: 'HASH-A', items: 'x' },
],
});
const result = await h.service.createWaveBatchByOrderIdsInTransaction({
warehouseId: WAREHOUSE_ID,
orderIds: [ 101, 102, 103 ],
waveType: 1,
wavePrefix: 'T',
source: 0,
transaction: h.transaction,
});
assert.strictEqual(result.waveId, 777);
assert.deepStrictEqual(result.selectedOrderIds, [ 101, 103 ]);
// 建波 total_orders 按复筛后的可用订单数
assert.strictEqual(h.waveReadyCalls[0].totalOrders, 2);
// 复筛 where 携带 wave_id=0,被先占的 102 不在更新范围
assert.deepStrictEqual(h.updateCalls[0].queryOptions.where.wave_id, 0);
const updateIds = h.updateCalls[0].queryOptions.where.id[Sequelize.Op.in];
assert.deepStrictEqual([ ...updateIds ].sort((a, b) => a - b), [ 101, 103 ]);
// 锁查询携带行锁
assert.strictEqual(h.findAllCalls[0].lock, 'UPDATE');
// 抓取数与锁数一致时无需回填
assert.strictEqual(h.queryCalls.some(call => call.sql.includes('total_orders')), false);
assert.strictEqual(occupied.wave_id, 999, '被先占订单不应被改写');
});
t('D2 锁后再次被占(grabbed < fetchable):total_orders 回填为实际抓取数', async () => {
const h = buildWaveCreationHarness({
lockRows: [
{ id: 101, wave_id: 0, items_hash: 'HASH-A', items: 'x' },
{ id: 103, wave_id: 0, items_hash: 'HASH-A', items: 'x' },
],
grabbedRows: [{ id: 101, wave_id: 0, items_hash: 'HASH-A', items: 'x' }],
});
const result = await h.service.createWaveBatchByOrderIdsInTransaction({
warehouseId: WAREHOUSE_ID,
orderIds: [ 101, 102, 103 ],
waveType: 1,
wavePrefix: 'T',
source: 0,
transaction: h.transaction,
});
assert.deepStrictEqual(result.selectedOrderIds, [ 101 ]);
const backfill = h.queryCalls.find(call => call.sql.includes('UPDATE wms_wave_batch') && call.sql.includes('total_orders'));
assert.strictEqual(Boolean(backfill), true);
assert.strictEqual(backfill.params.replacements.totalOrders, 1);
assert.strictEqual(backfill.params.replacements.waveId, 777);
});
t('D3 全部候选被先占(无可用订单):抛错且不建波', async () => {
const h = buildWaveCreationHarness({ lockRows: [], grabbedRows: [] });
await assert.rejects(
() => h.service.createWaveBatchByOrderIdsInTransaction({
warehouseId: WAREHOUSE_ID,
orderIds: [ 101, 102 ],
waveType: 1,
wavePrefix: 'T',
source: 0,
transaction: h.transaction,
}),
/候选订单已被占用或状态变化/
);
assert.strictEqual(h.waveReadyCalls.length, 0);
});
});
// ---------------------------------------------------------------------------
// E. 管理后台/直接抓取链路不经过合并(回归点 5)
// ---------------------------------------------------------------------------
const suiteE = suite('E. 后台抓取链路不经过合并(回归点 5)', t => {
t('E1 源码静态:合并方法仅由 autoPopulateWaveStrategyFetchSelections 调用一次', () => {
const source = fs.readFileSync(WAVE_SOURCE_FILE, 'utf8');
const lines = source.split('\n');
const autoStart = lines.findIndex(line => line.includes('async autoPopulateWaveStrategyFetchSelections('));
const directStart = lines.findIndex(line => line.includes('async executeWaveStrategyDirectFetch('));
assert.strictEqual(autoStart > 0, true);
assert.strictEqual(directStart > autoStart, true);
const mergeCallMatches = [ ...source.matchAll(/this\.mergeWaveStrategyFirstPoolSameStructureOrders\(/g) ];
assert.strictEqual(mergeCallMatches.length, 1);
const callLine = source.slice(0, mergeCallMatches[0].index).split('\n').length;
assert.strictEqual(callLine > autoStart && callLine < directStart, true);
const autoCallMatches = [ ...source.matchAll(/this\.autoPopulateWaveStrategyFetchSelections\(/g) ];
assert.strictEqual(autoCallMatches.length, 1);
});
t('E2 源码静态:PDA 入口走自动补齐,后台入口走直接抓取且不含合并', () => {
const source = fs.readFileSync(WAVE_SOURCE_FILE, 'utf8');
const pdaStart = source.indexOf('async waveStrategyFetchPda(data = {}) {');
const adminStart = source.indexOf('async waveStrategyFetchAdmin(data = {}) {');
assert.strictEqual(pdaStart > 0, true);
assert.strictEqual(adminStart > 0, true);
const pdaBody = source.slice(pdaStart, source.indexOf('async cancelWavePickTasksInternal', pdaStart));
assert.strictEqual(pdaBody.includes('autoPopulateSelections: true'), true);
assert.strictEqual(pdaBody.includes('executeWaveStrategyDirectFetch'), false);
const adminBody = source.slice(adminStart, source.indexOf('async deleteOrderWaveIndexByOrderIds', adminStart));
assert.strictEqual(adminBody.includes('executeWaveStrategyDirectFetch'), true);
assert.strictEqual(adminBody.includes('autoPopulateWaveStrategyFetchSelections'), false);
assert.strictEqual(adminBody.includes('mergeWaveStrategyFirstPoolSameStructureOrders'), false);
});
t('E3 运行时:executeWaveStrategyDirectFetch 不调用合并且建波结果正确', async () => {
const h = buildHarness({
firstPoolRows: [],
secondPoolRows: [ orderRow(101, 'HASH-A'), orderRow(102, 'HASH-A') ],
});
const creations = recordWaveCreations(h.service);
forbidMerge(h.service);
const result = await h.service.executeWaveStrategyDirectFetch({
plan: buildPlan(1),
strategyRow: buildStrategyRow(),
waveBatchSource: 0,
});
assert.strictEqual(result.created_wave_count, 1);
assert.deepStrictEqual(result.order_ids, [ 101, 102 ]);
assert.strictEqual(creations.length, 1);
});
t('E4 运行时:waveStrategyFetchAdmin 委托 executeWaveStrategyDirectFetch,不经过合并', async () => {
const h = buildHarness();
const strategyRow = buildStrategyRow({ group_batch_max_orders: 2 });
h.service.getWaveStrategyQuickScanStrategyRows = async () => [
{ ...strategyRow, id: STRATEGY_ID, strategy_id: STRATEGY_ID },
];
const directFetchCalls = [];
h.service.executeWaveStrategyDirectFetch = async params => {
directFetchCalls.push(params);
return {
wave_ids: [ 900 ],
wave_nos: [ 'T900' ],
order_ids: [ 101 ],
created_wave_count: 1,
created_order_count: 1,
wave_prefix: 'T',
wave_prefix_source: 'strategy',
candidate_count: 1,
grouped_count: 1,
strategy_type: 2,
};
};
forbidMerge(h.service);
const result = await h.service.waveStrategyFetchAdmin({ strategy_id: STRATEGY_ID });
assert.strictEqual(result.flag, 'success');
assert.strictEqual(directFetchCalls.length, 1);
assert.strictEqual(directFetchCalls[0].waveBatchSource, 0);
assert.strictEqual(result.created_wave_count, 1);
});
});
run([
suiteA,
suiteB,
suiteC,
suiteD,
suiteE,
]);