feat: 小团购PDA抓取跨池同结构合并

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

View File

@ -11335,6 +11335,166 @@ class WaveService extends OrderBaseService {
};
}
/**
* 小团购第一池抓取时合并同结构全池订单(修复「1 单 1 波次」问题)。
*
* 背景:波次抓取链路将订单池按「今日前 / 今日」分割,第一池非空时只抓第一池;
* 但候选 SQL 的同结构计数子查询为「全池统计」(不限策略、不含池边界),
* 导致某结构第一池仅剩 1 条时仍能通过 min_same_structure 门槛而单独成波。
*
* 合并口径:针对第一池候选分组中出现过的结构 key(require_same_express=1 时为
* 「结构+快递」组合,快递口径复用候选 SQL 中 expressExpr 的 COALESCE 优先级),
* 按候选 SQL 中同结构计数子查询的过筛口径(不限策略匹配、不含池边界 create_at 条件)
* 查询同结构全池订单,将两池同结构订单全部并入候选,后续复用既有分组与建波流程。
*
* 门控条件(任一不满足则返回 null 跳过合并、维持现状):
* - 仅小团购(pickMode === 1)生效,大团购(pickMode === 5)不覆盖;
* - 仅第一池非空(candidatePoolStage === 'first')时生效;
* - 仅 max_same_structure 已设置且有效(正整数且非 999)时生效,
* 未设置(null/999)的团购策略跳过合并;
* - 同结构全池查询无新增订单(如该结构订单全部在第一池)时不合并。
*
* @param {Object} params 合并参数。
* @param {number|string} params.warehouseId 仓库ID。
* @param {Object} params.strategyRow 策略行。
* @param {Array<Object>} params.candidateRows 当前候选订单(第一池)。
* @param {Array<Object>} params.effectiveGroupedRows 第一池候选分组结果。
* @param {string} params.candidatePoolStage 候选池阶段(first-第一池/second-第二池)。
* @param {number|string} params.pickMode 拣货模式。
* @param {boolean} params.requireSameExpress 是否要求同快递。
* @param {Object} params.transaction 事务对象(合并查询与后续建波共用同一事务)。
* @return {Promise<Array<Object>|null>} 合并后的候选订单数组;跳过合并时返回 null。
*/
async mergeWaveStrategyFirstPoolSameStructureOrders(params = {}) {
const warehouseId = this.normalizeRequiredPositiveInteger(params.warehouseId, 'warehouse_id');
const strategyRow = this.isPlainObject(params.strategyRow) ? params.strategyRow : {};
const candidateRows = Array.isArray(params.candidateRows) ? params.candidateRows : [];
const effectiveGroupedRows = Array.isArray(params.effectiveGroupedRows) ? params.effectiveGroupedRows : [];
const candidatePoolStage = String(params.candidatePoolStage || '').trim();
const pickMode = Number(params.pickMode || 0);
const requireSameExpress = Boolean(params.requireSameExpress);
const transaction = params.transaction;
// 门控一:仅小团购(pickMode=1)且第一池非空时执行合并
if (pickMode !== 1 || candidatePoolStage !== 'first') {
return null;
}
// 门控二:max_same_structure 未设置(null/999)时跳过合并,维持现状;
// 已设置有效的策略保存期已被钳制到 min-1,合并后天然受限,无需额外截断。
const maxSameStructureRaw = Number(strategyRow.max_same_structure);
const maxSameStructureConfigured = Number.isInteger(maxSameStructureRaw)
&& maxSameStructureRaw > 0
&& maxSameStructureRaw !== 999;
if (!maxSameStructureConfigured) {
return null;
}
// 收集第一池候选分组中出现过的结构 key;
// require_same_express=1 时同时收集快递 key(分组均来自最大快递组,快递 key 唯一)。
const structureKeySet = new Set();
const expressKeySet = new Set();
for (const group of effectiveGroupedRows) {
const structureKey = String(group && group.structure_key || '').trim();
if (!structureKey) {
continue;
}
structureKeySet.add(structureKey);
if (requireSameExpress) {
const groupOrders = Array.isArray(group && group.orders) ? group.orders : [];
const expressKey = groupOrders.length > 0
? this.getWaveStrategyQuickScanExpressKey(groupOrders[0])
: '';
if (expressKey) {
expressKeySet.add(expressKey);
}
}
}
const structureKeys = [ ...structureKeySet ].sort();
const expressKeys = [ ...expressKeySet ].sort();
if (structureKeys.length === 0 || (requireSameExpress && expressKeys.length === 0)) {
return null;
}
const orderModel = await this.getOrderModel('pendingOrder', warehouseId);
const orderTableName = this.getModelTableSqlName(orderModel);
const structureExpr = alias => `${alias}.items_hash`;
const expressExpr = alias => `COALESCE(NULLIF(TRIM(COALESCE(${alias}.sys_logistics_code, '')), ''), NULLIF(TRIM(COALESCE(${alias}.logistics_code, '')), ''), TRIM(COALESCE(${alias}.logistics_name, '')))`;
const expressCondition = requireSameExpress ? ` AND ${expressExpr('o')} IN (:expressKeys)` : '';
const replacements = {
warehouseId,
structureKeys,
};
if (requireSameExpress) {
replacements.expressKeys = expressKeys;
}
// 复用候选 SQL 同结构计数子查询的过筛口径:不限策略匹配、不含池边界 create_at 条件,
// 将两池同结构订单全部取出;查询与建波共用同一事务,行锁与 wave_id=0 复筛由建波流程负责。
const rows = await this.ctx.model.query(`
SELECT
o.id,
o.items_hash,
o.items,
o.logistics_name,
o.sys_logistics_code,
o.logistics_code,
o.items_count,
o.items_total
FROM ${orderTableName} o
WHERE o.warehouse_id = :warehouseId
AND o.wave_id = 0
AND o.step != 0
AND o.post_status = 'fin'
AND o.storage_status = 'fin'
AND o.print_status != 'fin'
AND o.status != 'cancel'
AND o.outbound_status != 'padding'
AND o.intercept_status = 'none'
AND o.lock_status = 'none'
AND ${structureExpr('o')} IN (:structureKeys)${expressCondition}
ORDER BY o.id ASC
`, {
replacements,
type: this.ctx.model.QueryTypes.SELECT,
transaction,
});
// 行归一化口径与 getWaveStrategyFetchCandidateOrders 保持一致
const mergedRows = (Array.isArray(rows) ? rows : [])
.map(row => ({
id: Number(row && row.id || 0),
items_hash: String(row && row.items_hash || '').trim(),
items: String(row && row.items || '').trim(),
logistics_name: String(row && row.logistics_name || '').trim(),
sys_logistics_code: String(row && row.sys_logistics_code || '').trim(),
logistics_code: String(row && row.logistics_code || '').trim(),
items_count: Number(row && row.items_count || 0),
items_total: Number(row && row.items_total || 0),
}))
.filter(row => Number.isInteger(row.id) && row.id > 0)
.sort((a, b) => a.id - b.id);
if (mergedRows.length === 0) {
return null;
}
// 合并订单并入候选(按 id 去重,第一池候选与全池查询结果存在重叠)
const candidateIdSet = new Set(candidateRows.map(row => Number(row && row.id || 0)));
const mergedCandidateRows = [
...candidateRows,
...mergedRows.filter(row => !candidateIdSet.has(row.id)),
].sort((a, b) => Number(a.id || 0) - Number(b.id || 0));
// 无新增订单时视为无需合并,返回 null 维持现状
if (mergedCandidateRows.length <= candidateRows.length) {
return null;
}
return mergedCandidateRows;
}
/**
* 自动补齐按策略抓取的 selected_wave_ids / selected_order_ids。
*
@ -11345,6 +11505,9 @@ class WaveService extends OrderBaseService {
* - 第二订单池:其余订单(今日订单)。
* 只有第一订单池抓取完毕(候选为空)才会抓取第二订单池,确保前一天的订单优先出库。
*
* 小团购(pickMode=1)第一池抓取时,会将第一池候选分组中同结构的全池订单并入候选
* (见 mergeWaveStrategyFirstPoolSameStructureOrders),避免同结构订单被两池分割后单独成波。
*
* @param {Object} params 自动分流参数。
* @param {Object} params.plan 抓取计划。
* @param {Object} params.strategyRow 策略行。
@ -11418,6 +11581,7 @@ class WaveService extends OrderBaseService {
candidate_pool_stage: candidatePoolStage,
first_pool_candidate_count: firstPoolRows.length,
grouped_count: groupedRows.length,
merged_order_count: 0,
wave_prefix: '',
wave_prefix_source: '',
};
@ -11431,11 +11595,35 @@ class WaveService extends OrderBaseService {
result.wave_prefix_source = wavePrefixResolution.source;
if (strategyType === 2) {
const effectiveGroupedRows = Number(strategyRow.require_same_express || 0) === 1
const requireSameExpress = Number(strategyRow.require_same_express || 0) === 1;
let effectiveGroupedRows = requireSameExpress
? this.groupWaveStrategyFetchCandidateOrdersByStructure(
this.filterCandidateOrdersByRequireSameExpress(candidateRows)
)
: groupedRows;
// 小团购(pickMode=1)第一池抓取:将同结构全池订单并入候选,修复「1 单 1 波次」问题。
// 合并受 pickMode=1 + 第一池阶段 + max_same_structure 有效三重门控;
// pickMode=5(大团购)不生效,admin 抓取入口(executeWaveStrategyDirectFetch)不经过本方法。
const mergedCandidateRows = await this.mergeWaveStrategyFirstPoolSameStructureOrders({
warehouseId,
strategyRow,
candidateRows,
effectiveGroupedRows,
candidatePoolStage,
pickMode,
requireSameExpress,
transaction,
});
if (mergedCandidateRows !== null) {
result.merged_order_count = mergedCandidateRows.length - candidateRows.length;
effectiveGroupedRows = requireSameExpress
? this.groupWaveStrategyFetchCandidateOrdersByStructure(
this.filterCandidateOrdersByRequireSameExpress(mergedCandidateRows)
)
: this.groupWaveStrategyFetchCandidateOrdersByStructure(mergedCandidateRows);
}
const groupLimitRaw = Number(strategyRow.group_batch_max_orders || plan.box_limit || 0);
const groupLimit = Number.isInteger(groupLimitRaw) && groupLimitRaw > 0 ? groupLimitRaw : 1;
const selectedGroups = effectiveGroupedRows
@ -11548,6 +11736,7 @@ class WaveService extends OrderBaseService {
candidate_count: result.candidate_count,
candidate_pool_stage: result.candidate_pool_stage,
first_pool_candidate_count: result.first_pool_candidate_count,
merged_order_count: result.merged_order_count,
today_start: todayStart,
removed_count: result.removed_order_ids.length,
selected_count: result.selected_order_ids.length,

View File

@ -1,4 +1,24 @@
[
{
"version": "2026.09.08-wave-strategy-group-buy-cross-pool-merge",
"date": "2026-09-08",
"type": "changed",
"summary": "小团购 PDA 抓取跨池同结构合并文档同步(修复「1 单 1 波次」问题):order.wave.waveStrategyFetchPda 抓取主流程新增小团购跨池同结构合并工序(mergeWaveStrategyFirstPoolSameStructureOrders),自动分流执行结果 result 新增 merged_order_count 字段(合并进候选的跨池订单数量,无合并时为 0);触发条件为小团购 pickMode=1 + 第一池非空 + max_same_structure 为正整数且≠999,max_same_structure 为 null/999 的策略、大团购 pickMode=5 与后台抓取入口行为不变。",
"methods": [
"order.wave.waveStrategyFetchPda"
],
"module": "order.wave",
"notes": [
"app/service/systemMethods/order/wave.js:新增私有方法 mergeWaveStrategyFirstPoolSameStructureOrders(约 L11339~L11495):按第一池候选分组出现过的 structure_key(require_same_express=1 时为「结构+快递」组合,快递口径复用候选 SQL expressExpr 的 COALESCE 优先级 sys_logistics_code > logistics_code > logistics_name)查询同结构全池过筛订单(wave_id=0、step!=0、post_status/storage_status=fin、print_status!=fin、status!=cancel、outbound_status!=padding、intercept_status=none、lock_status=none,不限策略匹配、不含池边界 create_at 条件),将两池同结构订单全部并入候选(按 id 去重)后复用既有分组建波流程;任一门控不满足返回 null 跳过合并",
"app/service/systemMethods/order/wave.js:autoPopulateWaveStrategyFetchSelections 团购分支(strategy_type=2 且 pickMode=1)接入合并:仅 pickMode=1 且 candidate_pool_stage='first' 且 max_same_structure 为正整数且≠999 时执行合并,merged_order_count = 合并后候选数 - 原候选数;max_same_structure 为 null/999、pickMode=5(大团购)、第一池为空、全池查询无新增订单时 merged_order_count=0 维持现状;后台抓取入口(executeWaveStrategyDirectFetch / waveStrategyFetchAdmin)不经过本方法不受影响",
"背景:订单池按今日前/今日分割 + min_same_structure 全池计数口径导致某结构第一池仅剩 1 条时仍通过门槛单独成波(生产订单 11103 案例「1 单 1 波次」)",
"methods/system.json:order.wave.waveStrategyFetchPda 条目 response 数组末尾新增 merged_order_count 字段说明(合并进候选的跨池订单数量、无合并为 0、不含在原 candidate_count 内、合并后候选总量 = candidate_count + merged_order_count);description 补充小团购跨池同结构合并规则(触发条件与跳过条件);params/headers 不变;errors 条目键名由 description 规范化为 message(文案不变,满足更新脚本 schema,与 order.wave.waveStrategyList 等先例一致);docMeta.version 0.3.101 -> 0.3.102,updatedAt 保持 2026-09-08;本变更记录写入 methods/changes/system.json 数组首位",
"兼容性:merged_order_count 为自动分流执行结果 result 新增可选字段,向后兼容;pickMode=5(大团购)、max_same_structure 为 null/999 的策略、后台抓取入口与第一池为空的场景行为与改动前一致,无接口破坏性变更",
"回归验证:test/wave_first_pool_merge_regression_20260908.cjs 覆盖门控(pickMode/池阶段/max_same_structure)、快递组合口径、合并去重、merged_order_count 计数与建波结果(wms-test-agent 回归通过)",
"README.md / AI_TOOLBOX.md 无需同步:检索确认无 waveStrategyFetchPda 抓取数量口径描述;AI_METHOD_ROUTING.md 第 6 节为自动扫描函数清单,如需刷新可另行执行扫描脚本",
"本次仅同步文档,未修改任何业务代码,未执行数据库/Redis 写操作"
]
},
{
"version": "2026.09.08-wave-strategy-list-info-order-count",
"date": "2026-09-08",

View File

@ -1,7 +1,7 @@
{
"module": "system",
"description": "系统接口标准入口,method 对应系统内置方法,全部使用 POST 请求,参数统一放在 body 内",
"version": "0.3.101",
"version": "0.3.102",
"updatedAt": "2026-09-08",
"headers": [
{
@ -8255,7 +8255,7 @@
},
{
"method": "order.wave.waveStrategyFetchPda",
"description": "按策略提交并创建抓取主流程任务(PDA)。当前为最小主流程:进行入参校验并创建任务记录,返回创建结果与计划预览;后续扫描/执行阶段将扩展为完整执行流。 注意:当存在未完成任务时,接口返回 fetch_state=3 且同时返回 existing task_id/task_no,前端可直接进入拣货流程。",
"description": "按策略提交并创建抓取主流程任务(PDA)。当前为最小主流程:进行入参校验并创建任务记录,返回创建结果与计划预览;后续扫描/执行阶段将扩展为完整执行流。 注意:当存在未完成任务时,接口返回 fetch_state=3 且同时返回 existing task_id/task_no,前端可直接进入拣货流程。 小团购跨池同结构合并规则:候选订单按创建时间分割为第一池(今日 0 点前)与第二池(今日订单),只有第一池抓取完毕才抓取第二池;小团购(pickMode=1)第一池抓取时,按第一池候选分组出现过的结构 key(require_same_express=1 时为「结构+快递」组合)将同结构全池订单(不限策略匹配、不含池边界)并入候选,随后复用既有分组建波流程,修复同结构订单被两池分割后单独成波(1 单 1 波次)的问题。合并触发条件:小团购 pickMode=1、第一池非空(candidate_pool_stage=first)、策略 max_same_structure 为正整数且≠999;max_same_structure 为 null/999 的团购策略跳过合并维持现状,大团购 pickMode=5 与后台抓取入口(order.wave.waveStrategyFetchAdmin)不覆盖;同结构全池查询无新增订单时亦不合并。",
"isNeedAuth": false,
"isNeedLogin": true,
"headers": [
@ -8390,20 +8390,26 @@
"type": "boolean",
"required": false,
"description": "仅当 fetch_state=3 时为 true,表示前端可直接进入拣货流程"
},
{
"name": "merged_order_count",
"type": "number",
"required": false,
"description": "小团购(pickMode=1)第一池抓取时,同结构全池订单并入候选的新增订单数量(合并进候选的跨池订单数量,仅统计新增并入、不含第一池原候选);未触发合并或合并无新增订单时为 0。统计口径:本字段不包含在原 candidate_count(合并前候选订单数,位于抓取主流程自动分流执行结果 result 内)之中,合并生效后实际参与分组建波的候选订单总量 = candidate_count + merged_order_count(最终以 selected_order_ids 为准)。触发条件:团购策略(strategy_type=2)且 pickMode=1、第一池非空、策略 max_same_structure 为正整数且≠999;require_same_express=1 时按「结构+快递」组合合并。跳过条件:pickMode=5(大团购)、max_same_structure 为 null/999、第一池为空、同结构全池无新增订单;后台抓取入口(order.wave.waveStrategyFetchAdmin)不经过该合并。该字段来自抓取主流程自动分流执行结果 result(任务创建链路内部返回并写入审计日志)。"
}
],
"errors": [
{
"code": "400",
"description": "参数校验失败(详见 validation_errors)"
"message": "参数校验失败(详见 validation_errors)"
},
{
"code": "400",
"description": "未识别到当前仓库上下文"
"message": "未识别到当前仓库上下文"
},
{
"code": "500",
"description": "创建任务失败或内部错误,message 字段含简短说明"
"message": "创建任务失败或内部错误,message 字段含简短说明"
}
]
},

View File

@ -0,0 +1,807 @@
'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,
]);

View File

@ -0,0 +1,64 @@
# 小团购 PDA 抓取跨池同结构合并 — 回归测试报告
- 报告日期:2026-09-08
- 测试类型:**单元回归**(纯函数级,mock DB/事务,无任何数据库/Redis 写操作)
- 测试执行人:wms-test-agent
- 测试仓库 ID:`100000`(固定,仅用于内存脚本上下文,未落库)
## 一、测试目标
验证「小团购 PDA 抓取跨池同结构合并」改动,防止 1 单 1 波次回归:
> 订单池按「今日前 / 今日」分割,第一池非空只抓第一池;但 min_same_structure 同结构计数为全池口径,
> 导致某结构第一池只剩 1 条(如订单 11103)仍单独成波。修复方案:小团购(strategyType===2 且 pickMode===1)
> PDA 抓取时,第一池非空且 max_same_structure 有效(正整数且≠999)时,按第一池出现过的
> structure_key(require_same_express=1 时为结构+快递组合)查询「同结构全池过筛全部订单」
> (不限策略、不含池边界)并入候选,走既有分组建波。
## 二、测试范围与测试方式
| 范围 | 说明 |
|------|------|
| 主要改动 | `app/service/systemMethods/order/wave.js`:新增 `mergeWaveStrategyFirstPoolSameStructureOrders`(约 L11339~L11495);`autoPopulateWaveStrategyFetchSelections` 团购分支接入合并(约 L11596~L11624)、`result.merged_order_count`(L11584) |
| 关联链路 | `waveStrategyFetchPda`(L12812)→ `createWavePickTaskFromPlan`(L11784)→ `autoPopulateWaveStrategyFetchSelections`;建波 `createWaveBatchByOrderIdsInTransaction`(L11181);分组 `groupWaveStrategyFetchCandidateOrdersByStructure`;候选查询 `getWaveStrategyFetchCandidateOrders`(L10872) |
| 测试产物 | `test/wave_first_pool_merge_regression_20260908.cjs`(26 个用例,5 个 suite) |
| 测试方式 | 直接 require 生产代码 `WaveService` 类,构造 mock `ctx`(`ctx.model.query` 按 SQL 特征分发返回脚本化行数据、`ctx.model.OrderDeliveryFactory.getCurrentModel` 返回内存模型、事务对象为内存 token)。**不执行任何数据库/Redis 写操作**,不发起真实 HTTP 请求。 |
| 静态校验 | 源码调用点唯一性校验(合并方法仅在 autoPopulate 中调用一次);ESLint 检查(生产文件 + 测试文件)。 |
## 三、回归点结果表
| # | 回归点 | 结果 | 验证方式与说明 |
|---|--------|------|----------------|
| 1 | 小团购 + 团购策略 + max_same_structure 有效 + 第一池非空:两池同结构全部订单合并为 1 波次 | ✅ 通过 | C1:第一池 1 条(101),今日同结构 3 条(102/103/104),抓取后 `selected_order_ids=[101,102,103,104]`、单波次、`merged_order_count=3`、`candidate_pool_stage='first'`;A5/A7 校验合并 SQL 口径与去重排序 |
| 2 | require_same_express=1:仅并入「结构+同快递」组合,快递 COALESCE 口径一致 | ✅ 通过 | B1/B2/C2:合并 SQL 携带与候选 SQL 完全一致的 `COALESCE(NULLIF(TRIM(COALESCE(sys_logistics_code,''))),...)` 口径;同结构异快递(YT)不并入最终波次;B3 校验 JS 侧快递 key 优先级与 COALESCE 一致;B4 空快递 key 不合并 |
| 3 | max_same_structure 为 null/999 的策略:行为与改动前完全一致(不合并) | ✅ 通过 | A3/A4 + C3/C4:门控返回 null,不执行任何合并查询,`merged_order_count=0`,仅第一池订单建波 |
| 4 | pickMode=5(大团购)策略抓取:行为不变,不触发合并 | ✅ 通过 | A1 + C5:门控拦截,不执行合并查询,建波行为与改动前一致 |
| 5 | 管理后台 executeWaveStrategyDirectFetch / waveStrategyFetchAdmin 抓取:行为不变 | ✅ 通过 | E1(合并方法调用点全仓库唯一且位于 autoPopulate 内)、E2(PDA 入口走 autoPopulate、后台入口走 directFetch 且不含合并)、E3(directFetch 运行时零合并调用且建波正确)、E4(admin 委托 directFetch,waveBatchSource=0) |
| 6 | 第一池为空(直接抓全池)场景:不触发合并,结果与改动前一致 | ✅ 通过 | A2 + C6:`candidate_pool_stage='second'`,执行两次候选查询(一池为空+全池),无合并查询,`merged_order_count=0` |
| 7 | 并发:两路同时抓取,合并带出订单被先占(wave_id≠0)时,建波复筛只锁可用订单,波次 total_orders 回填正确 | ✅ 通过 | D1(锁仅命中 wave_id=0 订单,total_orders 按可用数 2 建波)、D2(锁后再次被占,`UPDATE wms_wave_batch SET total_orders=1` 回填正确)、D3(全部被占抛「候选订单已被占用或状态变化」且不建波) |
| 8 | group_batch_max_orders / box_limit 多组场景:选组顺序、建波数量与订单归属正确;merged_order_count 数值正确 | ✅ 通过 | C7:3 个结构(A/B/C)、`group_batch_max_orders=2`,按组内最小订单号选 A/B 两组各建 1 波,C 不入选;`merged_order_count=2`、`selected_order_ids=[101,102,201,202]`;C8 无新增订单时 `merged_order_count=0` |
**汇总:8/8 回归点全部通过;26 个用例通过、0 失败。ESLint(生产文件 + 测试文件)0 错误 0 警告。**
## 四、问题清单与建议
| # | 级别 | 问题 | 建议 |
|---|------|------|------|
| 1 | 低风险观察 | 合并 SQL 仅按 `items_hash IN (:structureKeys)` 查询全池;而 JS 分组 key `getWaveStrategyQuickScanStructureKey` 在 items_hash 为空时会回退使用 `items` 字段。若存在 items_hash 为空的候选订单,合并查询将匹配不到同结构订单而返回 null(不合并),表现为该边缘场景修复不生效,但不会错误并入订单。 | 确认线上 pendingOrder 是否存在 items_hash 为空的订单;如存在,可考虑在合并查询中兼容 `items` 回退口径(与分组逻辑对齐)。 |
| 2 | 说明 | 合并为「读全池并并入候选」,波次正确性完全依赖建波锁(`createWaveBatchByOrderIdsInTransaction` 的 FOR UPDATE + wave_id=0 复筛 + total_orders 回填),已由 D1~D3 验证。 | 无需改动;建议发布后监控日志中 `merged_order_count > 0` 且 `selected_wave_count` 异常的告警。 |
| 3 | 说明 | 本报告为纯函数级回归,未覆盖真实 DB 上的 HTTP 端到端(受「不执行数据库/Redis 写操作」约束)。PDA 入口 `waveStrategyFetchPda` 仅做了源码级链路校验(E2)。 | 如需要,可在测试仓(仓库 100000)用固定策略构造真实订单数据后补充一次端到端抓取验证。 |
## 五、结论与建议
**结论:可以进入文档同步与发布流程。**
依据:
1. 8 个回归点全部通过,核心目标(第一池 1 条同结构 + 今日同结构多条 → 合并单波次)验证成立,1 单 1 波次回归被阻断;
2. 门控三重条件(pickMode=1 / 第一池非空 / max_same_structure 有效非 999)逐一验证,null/999、大团购、后台抓取、全池抓取四条「不合并」路径行为与改动前一致;
3. require_same_express 快递口径与候选 SQL 完全一致,异快递不并入;
4. 并发先占场景建波复筛与 total_orders 回填正确;
5. ESLint 零错误零警告。
发布前建议:
- 关注问题清单 #1(items_hash 为空边缘),确认后可留待后续迭代;
- 文档同步时补充 `merged_order_count` 字段说明(PDA 抓取返回/日志)。