'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, ]);