- 小团购(pickMode=1)抓取新增跨池同结构合并工序,第一池出现的结构按全池过筛口径合并今日同结构订单一并建波,修复订单池今日/今日前分割导致同结构订单被拆散后的 1 单 1 波次问题(生产订单 11103) - 三重门控:仅小团购+第一池非空+max_same_structure 有效(null/999 跳过维持现状),大团购与后台抓取不覆盖 - 新增 merged_order_count 统计字段;同步 methods 文档与变更记录 - 回归 26 用例全部通过
808 lines
34 KiB
JavaScript
808 lines
34 KiB
JavaScript
'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,
|
||
]);
|