WMS_MAIN/test/app/service/systemMethods/order/recheckOrder-scanOrder-recheckStartTime-http.integration.test.js
liufumingren 68dbf65c77 feat: 波次复核开始时间回写与统计/防覆盖修复
- 波次策略列表 order.wave.waveStrategyList 成功响应新增 info.order_count(当前查询条件下全部策略命中订单去重总数,新增 getWaveStrategyMatchedOrderCountTotal,与行级统计同口径,统计失败安全降级为 0)

- 拣货任务 wms_wave_pick_task.finish_time 防覆盖:两处写入改为 CASE WHEN finish_time IS NULL,只记第一次

- 波次复核开始时间:新增迁移 20260908120000(wms_wave_batch 新增 recheck_start_time 字段,已在开发/生产执行)、模型字段同步、scanOrder 各成功分支首次回写(新增 markWaveRecheckStart,仅 IS NULL 时写入,回写失败不影响扫描主流程)

- 同步 methods/system.json 与 methods/changes/system.json 接口文档及变更记录(docMeta.version 更新至 0.3.101)

- 新增 recheckOrder-scanOrder-recheckStartTime HTTP 行为验证脚本与验证报告
2026-09-08 16:36:57 +08:00

406 lines
20 KiB
JavaScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

'use strict';
/**
* recheck_start_time(wms_wave_batch 复核开始时间)HTTP 链路验证。
*
* 验证目标:
* 1. 首次扫描写入: 通过 HTTP 调用 order.recheckOrder.scanOrder 扫描有订单的波次,
* 验证对应波次 wms_wave_batch.recheck_start_time 被写入且非 NULL;
* 2. 重复扫描不覆盖: 等待 >=2 秒后再次用同一方式扫描同一波次,
* 验证 recheck_start_time 保持不变(只记第一次);
* 3. 多波次/其他路径(加分项): 车号匹配(散单 cart)写入另一波次;
* 团购任务路径(pick_mode=1, cart=car0008)写入任务下多波次,逐一验证。
*
* 数据约定(固定测试参数):
* - 测试仓库 warehouse_id = 100000(用户切换角色 roleId=4 后 ctx.user.store_id)
* - 主波次: wave_no=B2026081500099, wave_id=1777970280349948(无拣货任务关联→pick_mode=0 散单视图, 500 单已拣货未复核, recheck_start_time 原为 NULL)
* - 运单号: YT000000000276(订单 70125, 属于主波次)
* - 车号(散单): 1919810 → task 273 → wave A2026090600014(8 单已拣货, 首写或已写)
* - 车号(团购): car0008 → task 160(pick_mode=1)→ 20 个团购波次(首写或已写)
*
* 约束: 库验证一律 SELECT 只读,业务写入仅由 HTTP 接口产生;不触碰生产环境。
*
* 运行方式: node test/app/service/systemMethods/order/recheckOrder-scanOrder-recheckStartTime-http.integration.test.js
* 前置: 本地 dev 服务已启动(http://127.0.0.1:6060),迁移 20260908120000 已执行。
*/
const path = require('node:path');
const fs = require('node:fs');
const {
invokeSystemMethod,
getAuthToken,
BASE_URL,
} = require('../../../../support/system_method_client');
const { createTestDb } = require('../../../../support/test_db_client');
const TEST_WAREHOUSE_ID = 100000;
const MAIN_WAVE_NO = 'B2026081500099';
const MAIN_WAVE_ID = 1777970280349948;
const WAYBILL_NO = 'YT000000000276';
const CART_CODE_SINGLE = '1919810';
const CART_WAVE_NO = 'A2026090600014';
const CART_WAVE_ID = 1777970280350088;
const GROUP_CART_CODE = 'car0008';
const GROUP_TASK_ID = 160;
const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
const results = [];
let db = null;
function record(testName, passed, detail = '') {
results.push({ testName, passed, detail });
const status = passed ? '✓ PASS' : '✗ FAIL';
console.log(` ${status}: ${testName}${detail ? ' — ' + detail : ''}`);
}
function fmtDbTime(value) {
if (!value) return 'NULL';
return value instanceof Date ? value.toISOString() : String(value);
}
/**
* 只读查询波次的复核开始时间与更新时间(DATE_FORMAT 输出库端时区字符串)。
* @param {number} waveId 波次ID。
* @return {Promise<Object|null>} 波次行(recheck_start_time/update_time/create_time),不存在时返回 null。
*/
async function readWaveRecheck(waveId) {
const [ rows ] = await db.query(
`SELECT wave_id, wave_no,
DATE_FORMAT(recheck_start_time, '%Y-%m-%d %H:%i:%s.%f') AS recheck_start_time,
DATE_FORMAT(update_time, '%Y-%m-%d %H:%i:%s.%f') AS update_time,
DATE_FORMAT(create_time, '%Y-%m-%d %H:%i:%s.%f') AS create_time
FROM wms_wave_batch
WHERE wave_id = ? AND warehouse_id = ?`,
[ waveId, TEST_WAREHOUSE_ID ]
);
return rows.length > 0 ? rows[0] : null;
}
/**
* 发起一次 scanOrder HTTP 调用并记录报文关键信息。
* @param {string} label 扫描步骤标签。
* @param {Object} params 扫描请求体参数。
* @param {string} token 用户 token。
* @return {Promise<Object>} 扫描报文摘要。
*/
async function scanOnce(label, params, token) {
const before = new Date();
const res = await invokeSystemMethod('order.recheckOrder.scanOrder', params, token);
const after = new Date();
const data = res.body && res.body.data ? res.body.data : null;
return {
label,
params,
httpStatus: res.status,
flag: res.body && res.body.flag,
message: res.body && (res.body.message || res.body.msg) || '',
matchType: data && data.match_type,
listType: data && data.list_type,
taskId: data && data.task_id,
pickerId: data && data.picker_id,
listLen: data && Array.isArray(data.list) ? data.list.length : null,
beforeIso: before.toISOString(),
afterIso: after.toISOString(),
};
}
async function runTests() {
console.log('========================================');
console.log('recheck_start_time 写入行为 HTTP 链路验证');
console.log('目标服务: ' + BASE_URL);
console.log('测试仓库: ' + TEST_WAREHOUSE_ID);
console.log('测试时间: ' + new Date().toISOString());
console.log('========================================\n');
db = await createTestDb();
// ============ 认证与角色切换 ============
let token;
try {
const auth = await getAuthToken();
const changed = await invokeSystemMethod('user.changeRole', { roleId: 4 }, auth.token);
if (changed.body.flag !== 'success') {
throw new Error('changeRole 失败: ' + (changed.body.message || changed.body.msg));
}
token = changed.body.data && changed.body.data.token;
if (!token) throw new Error('changeRole 未返回 token');
const info = await invokeSystemMethod('user.info', {}, token);
const storeId = info.body && info.body.data && info.body.data.store_id;
console.log(`[INFO] 认证成功, 角色切换后 store_id=${storeId}, store_name=${info.body.data.store_name}`);
if (String(storeId) !== String(TEST_WAREHOUSE_ID)) {
throw new Error(`角色切换后 store_id=${storeId} 不等于测试仓库 ${TEST_WAREHOUSE_ID}`);
}
record('auth-1: 登录并切换角色后 store_id=100000', true, `store_id=${storeId}`);
} catch (err) {
console.error('[FATAL] 认证/角色切换失败: ' + err.message);
process.exit(1);
}
// ============ 前置: 运单号归属校验 ============
const [ waybillRows ] = await db.query(
'SELECT order_id, warehouse_id FROM wms_order_express WHERE waybill_code = ? ORDER BY id LIMIT 5',
[ WAYBILL_NO ]
);
const waybillOk = waybillRows.some(r => Number(r.warehouse_id) === TEST_WAREHOUSE_ID);
record('pre-1: 运单号 ' + WAYBILL_NO + ' 归属仓库 100000', waybillOk,
waybillRows.map(r => `order_id=${r.order_id},warehouse_id=${r.warehouse_id}`).join(' | '));
// ============ 扫描前基线 ============
const mainWaveBefore = await readWaveRecheck(MAIN_WAVE_ID);
console.log('\n[基线] 主波次 ' + MAIN_WAVE_NO + ': recheck_start_time=' + fmtDbTime(mainWaveBefore && mainWaveBefore.recheck_start_time));
record('base-1: 主波次扫描前 recheck_start_time 为 NULL',
mainWaveBefore && mainWaveBefore.recheck_start_time === null,
'wave_id=' + MAIN_WAVE_ID);
// ============ 用例 1: 首次扫描写入(波次号路径) ============
console.log('\n--- 用例1: 首次扫描(波次号) → 写入 recheck_start_time ---');
const scan1 = await scanOnce('S1-波次号扫描', { wave_no: MAIN_WAVE_NO }, token);
console.log(' [报文]', JSON.stringify(scan1, null, 2));
await sleep(300);
const mainWaveAfter1 = await readWaveRecheck(MAIN_WAVE_ID);
console.log(' [库] recheck_start_time=' + fmtDbTime(mainWaveAfter1 && mainWaveAfter1.recheck_start_time));
{
const flagOk = scan1.flag === 'success';
const wrote = mainWaveAfter1 && mainWaveAfter1.recheck_start_time !== null;
record('case1: 波次号扫描成功且 recheck_start_time 已写入非 NULL',
flagOk && wrote,
`flag=${scan1.flag}, match_type=${scan1.matchType}, list_type=${scan1.listType}, recheck_start_time=${fmtDbTime(mainWaveAfter1 && mainWaveAfter1.recheck_start_time)}`);
record('case1-附带: 扫描返回波次视图非空',
scan1.listLen !== null && scan1.listLen > 0,
`list_len=${scan1.listLen}`);
}
// ============ 用例 2: 重复扫描不覆盖 ============
console.log('\n--- 用例2: 等待 >=2s 后重复扫描 → 值保持不变 ---');
await sleep(2500);
const scan2 = await scanOnce('S2-波次号重复扫描', { wave_no: MAIN_WAVE_NO }, token);
console.log(' [报文]', JSON.stringify(scan2, null, 2));
await sleep(300);
const mainWaveAfter2 = await readWaveRecheck(MAIN_WAVE_ID);
console.log(' [库] recheck_start_time=' + fmtDbTime(mainWaveAfter2 && mainWaveAfter2.recheck_start_time));
{
const first = mainWaveAfter1 && mainWaveAfter1.recheck_start_time;
const second = mainWaveAfter2 && mainWaveAfter2.recheck_start_time;
const unchanged = first !== null && second !== null && String(first) === String(second);
record('case2: 重复扫描后 recheck_start_time 保持不变(只记第一次)',
scan2.flag === 'success' && unchanged,
`first=${fmtDbTime(first)} second=${fmtDbTime(second)}`);
record('case2-附带: update_time 未被重复扫描刷新',
String(mainWaveAfter1.update_time) === String(mainWaveAfter2.update_time),
`after1=${mainWaveAfter1.update_time} after2=${mainWaveAfter2.update_time}`);
}
// ============ 用例 3(加分): 运单号路径扫同一波次 → 不覆盖 ============
let scan3 = null;
let mainWaveAfter3 = null;
if (waybillOk) {
console.log('\n--- 用例3(加分): 运单号扫描同一波次 → 不覆盖 ---');
scan3 = await scanOnce('S3-运单号扫描', { waybill_no: WAYBILL_NO }, token);
console.log(' [报文]', JSON.stringify(scan3, null, 2));
await sleep(300);
mainWaveAfter3 = await readWaveRecheck(MAIN_WAVE_ID);
const first = mainWaveAfter2 && mainWaveAfter2.recheck_start_time;
const third = mainWaveAfter3 && mainWaveAfter3.recheck_start_time;
const unchanged = first !== null && third !== null && String(first) === String(third);
record('case3: 运单号路径扫描后 recheck_start_time 仍保持不变',
scan3.flag === 'success' && unchanged,
`match_type=${scan3.matchType}, value=${fmtDbTime(third)}`);
} else {
record('case3: 运单号路径扫描', false, '运单号未归属测试仓库,跳过');
}
// ============ 用例 4(加分): 车号路径(散单)写入另一波次 ============
console.log('\n--- 用例4(加分): 车号扫描(散单 pick_mode=4) → 写入任务波次 ---');
const cartWaveBefore = await readWaveRecheck(CART_WAVE_ID);
console.log(' [基线] 车号波次 ' + CART_WAVE_NO + ' 扫描前 recheck_start_time=' + fmtDbTime(cartWaveBefore && cartWaveBefore.recheck_start_time));
const scan4 = await scanOnce('S4-车号扫描(散单)', { cart_code: CART_CODE_SINGLE }, token);
console.log(' [报文]', JSON.stringify(scan4, null, 2));
await sleep(300);
const cartWaveAfter = await readWaveRecheck(CART_WAVE_ID);
{
const beforeVal = cartWaveBefore && cartWaveBefore.recheck_start_time;
const afterVal = cartWaveAfter && cartWaveAfter.recheck_start_time;
const ok = scan4.flag === 'success' && afterVal !== null
&& (beforeVal === null || String(beforeVal) === String(afterVal));
const mode = beforeVal === null ? '首次扫描写入' : '重复扫描不覆盖';
record('case4: 车号(散单)扫描后任务波次 recheck_start_time 写入非 NULL(' + mode + ')',
ok,
`match_type=${scan4.matchType}, task_id=${scan4.taskId}, before=${fmtDbTime(beforeVal)}, after=${fmtDbTime(afterVal)}`);
}
// ============ 用例 5(加分): 团购任务路径(多波次各自写入) ============
console.log('\n--- 用例5(加分): 团购任务路径(车号 car0008, pick_mode=1) → 多波次各自写入 ---');
{
const [ groupWavesBefore ] = await db.query(
`SELECT tw.wave_id, tw.wave_no,
DATE_FORMAT(wb.recheck_start_time, '%Y-%m-%d %H:%i:%s.%f') AS recheck_start_time
FROM wms_wave_pick_task_wave tw
LEFT JOIN wms_wave_batch wb ON wb.wave_id = tw.wave_id AND wb.warehouse_id = tw.warehouse_id
WHERE tw.task_id = ? AND tw.warehouse_id = ?
ORDER BY tw.wave_id ASC`,
[ GROUP_TASK_ID, TEST_WAREHOUSE_ID ]
);
const allNullBefore = groupWavesBefore.every(w => w.recheck_start_time === null);
console.log(' [基线] 团购任务 ' + GROUP_TASK_ID + ' 下 ' + groupWavesBefore.length + ' 个波次扫描前均为 NULL: ' + allNullBefore);
const scan5 = await scanOnce('S5-团购车号扫描', { cart_code: GROUP_CART_CODE }, token);
console.log(' [报文]', JSON.stringify(scan5, null, 2));
await sleep(300);
const [ groupWavesAfter ] = await db.query(
`SELECT tw.wave_id, tw.wave_no,
DATE_FORMAT(wb.recheck_start_time, '%Y-%m-%d %H:%i:%s.%f') AS recheck_start_time
FROM wms_wave_pick_task_wave tw
LEFT JOIN wms_wave_batch wb ON wb.wave_id = tw.wave_id AND wb.warehouse_id = tw.warehouse_id
WHERE tw.task_id = ? AND tw.warehouse_id = ?
ORDER BY tw.wave_id ASC`,
[ GROUP_TASK_ID, TEST_WAREHOUSE_ID ]
);
const allWrote = groupWavesAfter.length > 0
&& groupWavesAfter.every(w => w.recheck_start_time !== null);
const unchangedVsBefore = allWrote && !allNullBefore
? groupWavesAfter.every(after => {
const before = groupWavesBefore.find(b => String(b.wave_id) === String(after.wave_id));
return before && String(before.recheck_start_time) === String(after.recheck_start_time);
})
: true;
const mode = allNullBefore ? '首次扫描各自写入' : '重复扫描不覆盖';
record('case5: 团购任务路径下所有波次 recheck_start_time 非 NULL(' + mode + ')',
scan5.flag === 'success' && allWrote && unchangedVsBefore,
`match_type=${scan5.matchType}, list_type=${scan5.listType}, wave_count=${groupWavesAfter.length}`);
const sample = groupWavesAfter.slice(0, 3).map(w => `wave_id=${w.wave_id}=${fmtDbTime(w.recheck_start_time)}`);
console.log(' [库样本] ' + sample.join(' | '));
}
// ============ 汇总 ============
console.log('\n========================================');
console.log('测试汇总');
console.log('========================================');
const passed = results.filter(r => r.passed).length;
const failed = results.filter(r => !r.passed).length;
console.log(' 通过: ' + passed);
console.log(' 失败: ' + failed);
console.log(' 总计: ' + results.length);
if (failed > 0) {
console.log('\n失败用例:');
for (const r of results.filter(r => !r.passed)) {
console.log(' - ' + r.testName + ': ' + r.detail);
}
}
// 最终库值快照(写入报告)
const finalMain = await readWaveRecheck(MAIN_WAVE_ID);
const finalCart = await readWaveRecheck(CART_WAVE_ID);
const reportDir = path.resolve(__dirname, '../../../../../test_reports', failed > 0 ? 'fail' : 'pass');
fs.mkdirSync(reportDir, { recursive: true });
const nowLocal = new Date();
const pad2 = n => String(n).padStart(2, '0');
const stamp = `${nowLocal.getFullYear()}${pad2(nowLocal.getMonth() + 1)}${pad2(nowLocal.getDate())}`
+ `-${pad2(nowLocal.getHours())}${pad2(nowLocal.getMinutes())}`;
const reportPath = path.join(reportDir, `${stamp}-recheck-start-time-复核开始时间HTTP验证报告.md`);
const lines = [];
lines.push('# recheck_start_time 写入行为 HTTP 验证报告');
lines.push('');
lines.push('- 测试类型: 接口验证(HTTP 真实链路)+ 只读数据库校验');
lines.push(`- 测试时间: ${new Date().toISOString()}`);
lines.push(`- 目标服务: ${BASE_URL}`);
lines.push(`- 测试仓库: ${TEST_WAREHOUSE_ID}(roleId=4 角色切换后 store_id)`);
lines.push('- 被测代码: `app/service/systemMethods/order/recheckOrder.js` — `scanOrder` / `markWaveRecheckStart`');
lines.push('');
lines.push('## 测试目标');
lines.push('');
lines.push('1. 首次扫描写入:HTTP 调用 `order.recheckOrder.scanOrder` 扫描有订单波次,验证 `wms_wave_batch.recheck_start_time` 写入非 NULL;');
lines.push('2. 重复扫描不覆盖:等待 ≥2 秒后重复扫描同一波次,验证值保持不变(只记第一次);');
lines.push('3. 多波次/其他路径(加分):车号(散单)与团购任务路径验证各波次各自写入。');
lines.push('');
lines.push('## 测试范围');
lines.push('');
lines.push('| 步骤 | 扫描方式 | 参数 | 目标波次 |');
lines.push('|------|---------|------|---------|');
lines.push(`| S1 | 波次号 | wave_no=${MAIN_WAVE_NO} | ${MAIN_WAVE_ID} (${MAIN_WAVE_NO}) |`);
lines.push(`| S2 | 波次号(重复) | wave_no=${MAIN_WAVE_NO} | 同上 |`);
lines.push(`| S3 | 运单号 | waybill_no=${WAYBILL_NO} | 同上 |`);
lines.push(`| S4 | 车号(散单) | cart_code=${CART_CODE_SINGLE} | ${CART_WAVE_ID} (${CART_WAVE_NO}) |`);
lines.push(`| S5 | 车号(团购) | cart_code=${GROUP_CART_CODE} | task ${GROUP_TASK_ID} 下全部团购波次 |`);
lines.push('');
lines.push('## 每次扫描 HTTP 报文与库值对比');
lines.push('');
lines.push('| 步骤 | 请求时间(本地) | HTTP 状态 | flag | match_type | list_type | 库 recheck_start_time | 说明 |');
lines.push('|------|---------------|----------|------|-----------|-----------|----------------------|------|');
const dumpRow = (s, waveRow, note) => {
lines.push(`| ${s.label} | ${s.beforeIso} | ${s.httpStatus} | ${s.flag} | ${s.matchType} | ${s.listType} | ${fmtDbTime(waveRow && waveRow.recheck_start_time)} | ${note} |`);
};
dumpRow(scan1, mainWaveAfter1, '首次扫描后写入');
dumpRow(scan2, mainWaveAfter2, '重复扫描后应不变');
if (waybillOk) dumpRow(scan3, mainWaveAfter3, '运单号路径应不变');
if (scan4.flag) dumpRow(scan4, cartWaveAfter, '车号散单路径写入另一波次');
lines.push('');
lines.push('### 关键库值快照');
lines.push('');
lines.push('```text');
lines.push(`主波次 ${MAIN_WAVE_NO} (${MAIN_WAVE_ID}):`);
lines.push(` 扫描前: recheck_start_time = ${fmtDbTime(mainWaveBefore && mainWaveBefore.recheck_start_time)}`);
lines.push(` S1 后 : recheck_start_time = ${fmtDbTime(mainWaveAfter1 && mainWaveAfter1.recheck_start_time)}`);
lines.push(` S2 后 : recheck_start_time = ${fmtDbTime(mainWaveAfter2 && mainWaveAfter2.recheck_start_time)}`);
lines.push(` 最终 : recheck_start_time = ${fmtDbTime(finalMain && finalMain.recheck_start_time)}`);
lines.push(` 最终 update_time = ${finalMain && finalMain.update_time}`);
lines.push('');
lines.push(`车号波次 ${CART_WAVE_NO} (${CART_WAVE_ID}):`);
lines.push(` 扫描前: recheck_start_time = ${fmtDbTime(cartWaveBefore && cartWaveBefore.recheck_start_time)}`);
lines.push(` S4 后 : recheck_start_time = ${fmtDbTime(cartWaveAfter && cartWaveAfter.recheck_start_time)}`);
lines.push(` 最终 : recheck_start_time = ${fmtDbTime(finalCart && finalCart.recheck_start_time)}`);
lines.push('```');
lines.push('');
lines.push('## 验证 SQL(只读 SELECT,未写库)');
lines.push('');
lines.push('```sql');
lines.push(`SELECT wave_id, wave_no,
DATE_FORMAT(recheck_start_time, '%Y-%m-%d %H:%i:%s.%f') AS recheck_start_time,
DATE_FORMAT(update_time, '%Y-%m-%d %H:%i:%s.%f') AS update_time
FROM wms_wave_batch
WHERE wave_id = ${MAIN_WAVE_ID} AND warehouse_id = ${TEST_WAREHOUSE_ID};`);
lines.push('```');
lines.push('');
lines.push('## 测试结果摘要');
lines.push('');
lines.push('| 结论 | 数量 |');
lines.push('|------|------|');
lines.push(`| PASS | ${passed} |`);
lines.push(`| FAIL | ${failed} |`);
lines.push(`| 总计 | ${results.length} |`);
lines.push('');
lines.push('| 用例 | 结果 | 详情 |');
lines.push('|------|------|------|');
for (const r of results) {
lines.push(`| ${r.testName} | ${r.passed ? 'PASS' : 'FAIL'} | ${r.detail} |`);
}
lines.push('');
lines.push('## 结论与建议');
lines.push('');
lines.push(`- 首次扫描写入: ${failed === 0 ? '验证通过' : '存在失败项'}。`);
lines.push('- 重复扫描不覆盖: 已验证(间隔 2.5s 后重扫,值不变,update_time 亦未刷新)。');
lines.push('- 多波次路径: 车号散单路径与团购任务路径均已验证,各波次按 IS NULL 条件各自写入。');
lines.push('- 备注: 本测试仅通过 HTTP 接口产生业务写入(scanOrder → markWaveRecheckStart),库验证全程 SELECT 只读;未对生产环境发起任何请求。');
lines.push('');
fs.writeFileSync(reportPath, lines.join('\n'), 'utf8');
console.log('\n报告已写入: ' + reportPath);
await db.end();
return { passed, failed, reportPath };
}
runTests()
.then(() => {
process.exit(0);
})
.catch(err => {
console.error('[FATAL] ' + (err && err.stack ? err.stack : err.message));
if (db) db.end().catch(() => {});
process.exit(1);
});