From d73c66c2f31b30a2a0e1eafd1de10bde857eebae Mon Sep 17 00:00:00 2001 From: liufumingren Date: Tue, 8 Sep 2026 21:38:53 +0800 Subject: [PATCH] =?UTF-8?q?feat:=20=E5=B0=8F=E5=9B=A2=E8=B4=ADPDA=E6=8A=93?= =?UTF-8?q?=E5=8F=96=E8=B7=A8=E6=B1=A0=E5=90=8C=E7=BB=93=E6=9E=84=E5=90=88?= =?UTF-8?q?=E5=B9=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 小团购(pickMode=1)抓取新增跨池同结构合并工序,第一池出现的结构按全池过筛口径合并今日同结构订单一并建波,修复订单池今日/今日前分割导致同结构订单被拆散后的 1 单 1 波次问题(生产订单 11103) - 三重门控:仅小团购+第一池非空+max_same_structure 有效(null/999 跳过维持现状),大团购与后台抓取不覆盖 - 新增 merged_order_count 统计字段;同步 methods 文档与变更记录 - 回归 26 用例全部通过 --- app/service/systemMethods/order/wave.js | 191 ++++- methods/changes/system.json | 20 + methods/system.json | 16 +- ...e_first_pool_merge_regression_20260908.cjs | 807 ++++++++++++++++++ ...小团购PDA抓取跨池同结构合并回归测试报告.md | 64 ++ 5 files changed, 1092 insertions(+), 6 deletions(-) create mode 100644 test/wave_first_pool_merge_regression_20260908.cjs create mode 100644 test_reports/pass/20260908-小团购PDA抓取跨池同结构合并回归测试报告.md diff --git a/app/service/systemMethods/order/wave.js b/app/service/systemMethods/order/wave.js index afd2307..94dcb95 100644 --- a/app/service/systemMethods/order/wave.js +++ b/app/service/systemMethods/order/wave.js @@ -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} params.candidateRows 当前候选订单(第一池)。 + * @param {Array} params.effectiveGroupedRows 第一池候选分组结果。 + * @param {string} params.candidatePoolStage 候选池阶段(first-第一池/second-第二池)。 + * @param {number|string} params.pickMode 拣货模式。 + * @param {boolean} params.requireSameExpress 是否要求同快递。 + * @param {Object} params.transaction 事务对象(合并查询与后续建波共用同一事务)。 + * @return {Promise|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, diff --git a/methods/changes/system.json b/methods/changes/system.json index d2fae7c..05dafc9 100644 --- a/methods/changes/system.json +++ b/methods/changes/system.json @@ -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", diff --git a/methods/system.json b/methods/system.json index a356dea..3c186c0 100644 --- a/methods/system.json +++ b/methods/system.json @@ -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 字段含简短说明" } ] }, diff --git a/test/wave_first_pool_merge_regression_20260908.cjs b/test/wave_first_pool_merge_regression_20260908.cjs new file mode 100644 index 0000000..0e09e6f --- /dev/null +++ b/test/wave_first_pool_merge_regression_20260908.cjs @@ -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} 建波调用记录数组。 + */ +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, +]); diff --git a/test_reports/pass/20260908-小团购PDA抓取跨池同结构合并回归测试报告.md b/test_reports/pass/20260908-小团购PDA抓取跨池同结构合并回归测试报告.md new file mode 100644 index 0000000..5ec0aa6 --- /dev/null +++ b/test_reports/pass/20260908-小团购PDA抓取跨池同结构合并回归测试报告.md @@ -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 抓取返回/日志)。