WMS_MAIN/test/app/service/systemMethods/order/wave.batchCancel.test.js

522 lines
18 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';
const assert = require('node:assert/strict');
const { Op } = require('sequelize');
const WaveService = require('../../../../../app/service/systemMethods/order/wave');
/** 批量取消任务缓存键前缀(与 wave.js 中的常量保持一致)。 */
const BATCH_CANCEL_TASK_CACHE_KEY_PREFIX = 'wave:batch-cancel:';
/**
* 等待若干轮事件循环(用于等待 batchCancel 内 setImmediate 触发的后台任务)。
*
* @param {number} [ticks=3] 轮次。
* @return {Promise<void>} 等待完成。
*/
function waitImmediate(ticks = 3) {
return new Promise(resolve => {
let remaining = ticks;
const step = () => {
remaining -= 1;
if (remaining <= 0) {
resolve();
return;
}
setImmediate(step);
};
setImmediate(step);
});
}
/**
* 创建 batchCancel 轻量测试上下文。
*
* @param {Object} [options] 场景配置。
* @param {Array<Object>} [options.orders] 订单记录(id/wave_id/wave_no/pick_status)。
* @param {Array<Object>} [options.waves] 波次记录(wave_id/wave_no/wave_status)。
* @param {Array<Object>} [options.activePickTaskWaves] 活动拣货任务波次行(wave_id)。
* @param {number} [options.warehouseId] 仓库ID(默认固定测试仓库 100000)。
* @return {{ service: WaveService, state: Object }} 服务实例与状态记录。
*/
function createHarness(options = {}) {
const warehouseId = Number(options.warehouseId || 100000);
const cacheStore = new Map();
const state = {
sqlCalls: [],
cacheKeys: [],
orderFindAllCalls: [],
orderUpdateCalls: [],
canceledWaveIds: [],
rollbackCount: 0,
backgroundTaskCalls: [],
orders: (options.orders || [
{ id: 101, wave_id: 11, wave_no: 'W11', pick_status: 'none' },
{ id: 102, wave_id: 11, wave_no: 'W11', pick_status: 'none' },
]).map(row => ({ ...row })),
waves: (options.waves || [
{ wave_id: 11, wave_no: 'W11', wave_status: 0 },
]).map(row => ({ ...row })),
activePickTaskWaves: options.activePickTaskWaves || [],
};
const transaction = {
async commit() {
// 轻量测试用空事务:提交不做任何事
},
async rollback() {
state.rollbackCount += 1;
},
};
const ctx = {
app: {
config: {},
async setCacheAsync(key, value) {
cacheStore.set(key, value);
if (!state.cacheKeys.includes(key)) {
state.cacheKeys.push(key);
}
},
async getCacheAsync(key) {
return cacheStore.get(key) || null;
},
},
user: {
store_id: warehouseId,
},
logger: {
info() {},
warn() {},
error() {},
},
model: {
QueryTypes: {
SELECT: 'SELECT',
},
async transaction() {
return transaction;
},
async query(sql, options = {}) {
state.sqlCalls.push({ sql, options });
// 入口校验:活动拣货任务波次查询
if (sql.includes('wms_wave_pick_task_wave')) {
return state.activePickTaskWaves;
}
// 波次批量表查询(入口 wave_status >= 3 兜底校验 / 后台任务波次加载)
if (sql.includes('SELECT wave_id, wave_no, wave_status')) {
const replacements = options.replacements || {};
const rawIds = replacements.ids || replacements.waveIds || [];
const requestedIds = (Array.isArray(rawIds) ? rawIds : [ rawIds ]).map(id => Number(id));
const matched = state.waves.filter(item => requestedIds.includes(Number(item.wave_id)));
if (sql.includes('wave_status >= 3')) {
return matched.filter(item => Number(item.wave_status) >= 3);
}
return matched;
}
if (sql.includes('DELETE FROM wms_order_wave_index')) {
return [[], { affectedRows: 2 }];
}
if (sql.includes('UPDATE wms_wave_batch') && sql.includes('SET wave_status = -1')) {
const waveId = Number(options.replacements && options.replacements.waveId || 0);
state.canceledWaveIds.push(waveId);
return [[], { affectedRows: 1 }];
}
return [[], { affectedRows: 0 }];
},
},
};
const service = new WaveService(ctx);
service.batchCreateOrderOperationLogs = async () => 0;
// 快扫副表清理/触发为取消链路外的旁路副作用,stub 掉以保持用例确定性(非取消语义本身)
service.enqueueWaveStrategyQuickScanPostOrderChange = () => {};
const matchWaveId = (row, waveIdCondition) => {
if (waveIdCondition && waveIdCondition[Op.in]) {
return waveIdCondition[Op.in].map(id => Number(id)).includes(Number(row.wave_id || 0));
}
return Number(row.wave_id || 0) === Number(waveIdCondition || 0);
};
const matchPickStatus = (row, pickStatusCondition) => {
if (pickStatusCondition === undefined) {
return true;
}
if (pickStatusCondition && pickStatusCondition[Op.in]) {
return pickStatusCondition[Op.in].includes(String(row.pick_status || ''));
}
return String(row.pick_status || '') === String(pickStatusCondition);
};
service.getOrderModel = async () => ({
async findAll(options = {}) {
const where = (options && options.where) || {};
state.orderFindAllCalls.push({ where });
return state.orders
.filter(item => matchWaveId(item, where.wave_id))
.filter(item => matchPickStatus(item, where.pick_status))
.map(item => ({ ...item }));
},
async update(values = {}, options = {}) {
const where = (options && options.where) || {};
state.orderUpdateCalls.push({ values, where });
let affected = 0;
for (const row of state.orders) {
if (!matchWaveId(row, where.wave_id)) {
continue;
}
row.wave_id = Number(values.wave_id || 0);
row.wave_no = String(values.wave_no || '');
affected += 1;
}
return [ affected ];
},
});
return {
service,
state,
};
}
describe('test/app/service/systemMethods/order/wave.batchCancel.test.js', () => {
it('runBatchCancelTask 应在取消波次时清理 wms_order_wave_index', async () => {
const { service, state } = createHarness();
await service.setBatchCancelTaskProgress('task_cancel_1', 'submitted', {
warehouse_id: 100000,
wave_ids: '11',
wave_id_list: [ 11 ],
});
await service.runBatchCancelTask({
taskId: 'task_cancel_1',
warehouseId: 100000,
waveIds: [ 11 ],
});
const deleteCall = state.sqlCalls.find(call => call.sql.includes('DELETE FROM wms_order_wave_index'));
assert.ok(deleteCall, '应删除波次索引');
assert.deepEqual(
deleteCall.options.replacements.waveIds.map(id => Number(id)),
[ 11 ]
);
const progress = await service.getBatchCancelTaskProgress('task_cancel_1');
assert.equal(progress.state, 'success');
assert.equal(progress.result.canceled_wave_count, 1);
assert.equal(progress.result.skipped_wave_count, 0);
assert.deepEqual(progress.result.skipped_wave_ids, []);
assert.deepEqual(progress.result.skipped_waves, []);
assert.equal(state.orders.every(order => order.wave_id === 0), true, '取消后订单应被移出波次');
});
it('batchCancel 波次内存在拣货中订单时应整体拒绝,不删除波次、不移出订单', async () => {
const { service, state } = createHarness({
waves: [
{ wave_id: 11, wave_no: 'W11', wave_status: 0 },
{ wave_id: 12, wave_no: 'W12', wave_status: 0 },
],
orders: [
{ id: 101, wave_id: 11, wave_no: 'W11', pick_status: 'padding' },
{ id: 102, wave_id: 11, wave_no: 'W11', pick_status: 'none' },
{ id: 103, wave_id: 12, wave_no: 'W12', pick_status: 'none' },
],
});
const result = await service.batchCancel({
warehouse_id: 100000,
wave_ids: [ 11, 12 ],
});
assert.equal(result.flag, 'failure');
assert.equal(result.code, 400);
assert.match(result.message, /禁止取消波次/);
assert.deepEqual(result.wave_ids, [ 11 ], '应仅返回存在拣货中订单的波次');
assert.deepEqual(result.order_ids, [ 101 ], '应返回命中拣货中订单');
// 整体拒绝:不得执行任何取消动作
assert.equal(
state.sqlCalls.some(call => call.sql.includes('DELETE FROM wms_order_wave_index')),
false,
'整体拒绝时不得删除波次索引'
);
assert.equal(
state.sqlCalls.some(call => call.sql.includes('SET wave_status = -1')),
false,
'整体拒绝时不得更新波次状态'
);
assert.equal(state.orderUpdateCalls.length, 0, '整体拒绝时不得移出订单');
assert.equal(
state.cacheKeys.some(key => key.startsWith(BATCH_CANCEL_TASK_CACHE_KEY_PREFIX)),
false,
'整体拒绝时不得提交后台取消任务'
);
assert.equal(state.orders.every(order => order.wave_id !== 0), true, '所有订单应保持原波次');
assert.equal(
state.orderFindAllCalls.some(call => call.where.pick_status && call.where.pick_status[Op.in]),
true,
'应执行拣货状态守卫查询'
);
});
it('batchCancel 波次内存在拣货完成订单时应整体拒绝', async () => {
const { service, state } = createHarness({
waves: [
{ wave_id: 11, wave_no: 'W11', wave_status: 1 },
],
orders: [
{ id: 101, wave_id: 11, wave_no: 'W11', pick_status: 'fin' },
{ id: 102, wave_id: 11, wave_no: 'W11', pick_status: 'none' },
],
});
const result = await service.batchCancel({
warehouse_id: 100000,
wave_ids: [ 11 ],
});
assert.equal(result.flag, 'failure');
assert.equal(result.code, 400);
assert.match(result.message, /禁止取消波次/);
assert.deepEqual(result.wave_ids, [ 11 ]);
assert.deepEqual(result.order_ids, [ 101 ]);
assert.equal(
state.sqlCalls.some(call => call.sql.includes('SET wave_status = -1')),
false
);
assert.equal(state.orderUpdateCalls.length, 0);
assert.equal(
state.cacheKeys.some(key => key.startsWith(BATCH_CANCEL_TASK_CACHE_KEY_PREFIX)),
false
);
});
it('batchCancel 波次已进入拣货及后续环节(wave_status >= 3)时应拒绝', async () => {
const { service, state } = createHarness({
waves: [
{ wave_id: 11, wave_no: 'W11', wave_status: 3 },
],
orders: [
{ id: 101, wave_id: 11, wave_no: 'W11', pick_status: 'none' },
],
});
const result = await service.batchCancel({
warehouse_id: 100000,
wave_ids: [ 11 ],
});
assert.equal(result.flag, 'failure');
assert.equal(result.code, 400);
assert.match(result.message, /禁止取消波次/);
assert.deepEqual(result.wave_ids, [ 11 ]);
assert.equal(
state.sqlCalls.some(call => call.sql.includes('wave_status >= 3')),
true,
'应执行 wave_status >= 3 兜底校验查询'
);
assert.equal(
state.sqlCalls.some(call => call.sql.includes('SET wave_status = -1')),
false
);
assert.equal(state.orderUpdateCalls.length, 0);
assert.equal(
state.cacheKeys.some(key => key.startsWith(BATCH_CANCEL_TASK_CACHE_KEY_PREFIX)),
false
);
});
it('batchCancel 未拣货波次(pick_status=none、wave_status<3)应正常提交取消任务', async () => {
const { service, state } = createHarness({
waves: [
{ wave_id: 11, wave_no: 'W11', wave_status: 1 },
],
orders: [
{ id: 101, wave_id: 11, wave_no: 'W11', pick_status: 'none' },
{ id: 102, wave_id: 11, wave_no: 'W11', pick_status: 'none' },
],
});
service.runBatchCancelTask = async params => {
state.backgroundTaskCalls.push({ ...params });
};
const result = await service.batchCancel({
warehouse_id: 100000,
wave_ids: [ 11 ],
});
assert.equal(result.flag, 'success');
assert.equal(typeof result.task_id, 'string');
assert.ok(result.task_id.length > 0);
assert.equal(result.message, '批量解除波次任务已提交。');
await waitImmediate();
assert.equal(state.backgroundTaskCalls.length, 1, '应触发后台取消任务');
assert.deepEqual(state.backgroundTaskCalls[0], {
taskId: result.task_id,
warehouseId: 100000,
waveIds: [ 11 ],
});
const submitted = await service.getBatchCancelTaskProgress(result.task_id);
assert.equal(submitted.state, 'submitted');
assert.equal(submitted.warehouse_id, 100000);
assert.equal(submitted.wave_ids, '11');
});
it('runBatchCancelTask 波次已进入拣货及后续环节时应跳过并返回 skipped_waves', async () => {
const { service, state } = createHarness({
waves: [
{ wave_id: 11, wave_no: 'W11', wave_status: 3 },
],
orders: [
{ id: 101, wave_id: 11, wave_no: 'W11', pick_status: 'none' },
],
});
await service.setBatchCancelTaskProgress('task_skip_status', 'submitted', {
warehouse_id: 100000,
wave_ids: '11',
wave_id_list: [ 11 ],
});
await service.runBatchCancelTask({
taskId: 'task_skip_status',
warehouseId: 100000,
waveIds: [ 11 ],
});
const progress = await service.getBatchCancelTaskProgress('task_skip_status');
assert.equal(progress.state, 'success');
assert.equal(progress.result.canceled_wave_count, 0);
assert.equal(progress.result.skipped_wave_count, 1);
assert.deepEqual(progress.result.skipped_wave_ids, [ 11 ]);
assert.deepEqual(progress.result.skipped_waves, [
{ wave_id: 11, wave_no: 'W11', reason: 'wave_status_blocked', wave_status: 3 },
]);
// 跳过时不得执行任何取消动作
assert.equal(
state.sqlCalls.some(call => call.sql.includes('SET wave_status = -1')),
false
);
assert.equal(
state.sqlCalls.some(call => call.sql.includes('DELETE FROM wms_order_wave_index')),
false
);
assert.equal(state.orderUpdateCalls.length, 0);
assert.equal(state.orders[0].wave_id, 11, '订单应保持原波次');
});
it('runBatchCancelTask 波次内存在拣货中/拣货完成订单时应跳过并记录 picked_orders_exist', async () => {
const { service, state } = createHarness({
waves: [
{ wave_id: 11, wave_no: 'W11', wave_status: 0 },
],
orders: [
{ id: 101, wave_id: 11, wave_no: 'W11', pick_status: 'padding' },
{ id: 102, wave_id: 11, wave_no: 'W11', pick_status: 'fin' },
{ id: 103, wave_id: 11, wave_no: 'W11', pick_status: 'none' },
],
});
await service.setBatchCancelTaskProgress('task_skip_picked', 'submitted', {
warehouse_id: 100000,
wave_ids: '11',
wave_id_list: [ 11 ],
});
await service.runBatchCancelTask({
taskId: 'task_skip_picked',
warehouseId: 100000,
waveIds: [ 11 ],
});
const progress = await service.getBatchCancelTaskProgress('task_skip_picked');
assert.equal(progress.state, 'success');
assert.equal(progress.result.canceled_wave_count, 0);
assert.equal(progress.result.skipped_wave_count, 1);
assert.deepEqual(progress.result.skipped_wave_ids, [ 11 ]);
assert.equal(progress.result.skipped_waves.length, 1);
assert.equal(progress.result.skipped_waves[0].wave_id, 11);
assert.equal(progress.result.skipped_waves[0].wave_no, 'W11');
assert.equal(progress.result.skipped_waves[0].reason, 'picked_orders_exist');
assert.equal(progress.result.skipped_waves[0].picked_order_count, 2);
assert.equal(state.rollbackCount, 1, '命中拣货守卫后应回滚事务');
assert.equal(
state.sqlCalls.some(call => call.sql.includes('SET wave_status = -1')),
false
);
assert.equal(
state.sqlCalls.some(call => call.sql.includes('DELETE FROM wms_order_wave_index')),
false
);
assert.equal(state.orderUpdateCalls.length, 0);
assert.equal(state.orders.every(order => order.wave_id === 11), true, '订单应保持原波次');
});
it('runBatchCancelTask 混合波次:正常波次取消、命中条件的波次跳过', async () => {
const { service, state } = createHarness({
waves: [
{ wave_id: 11, wave_no: 'W11', wave_status: 0 },
{ wave_id: 12, wave_no: 'W12', wave_status: 3 },
{ wave_id: 13, wave_no: 'W13', wave_status: 0 },
],
orders: [
{ id: 101, wave_id: 11, wave_no: 'W11', pick_status: 'none' },
{ id: 102, wave_id: 11, wave_no: 'W11', pick_status: 'none' },
{ id: 103, wave_id: 12, wave_no: 'W12', pick_status: 'none' },
{ id: 104, wave_id: 13, wave_no: 'W13', pick_status: 'padding' },
{ id: 105, wave_id: 13, wave_no: 'W13', pick_status: 'none' },
],
});
await service.setBatchCancelTaskProgress('task_mixed', 'submitted', {
warehouse_id: 100000,
wave_ids: '11,12,13',
wave_id_list: [ 11, 12, 13 ],
});
await service.runBatchCancelTask({
taskId: 'task_mixed',
warehouseId: 100000,
waveIds: [ 11, 12, 13 ],
});
const progress = await service.getBatchCancelTaskProgress('task_mixed');
assert.equal(progress.state, 'success');
assert.equal(progress.result.canceled_wave_count, 1);
assert.deepEqual(progress.result.affected_wave_ids, [ 11 ]);
assert.equal(progress.result.affected_order_count, 2);
assert.equal(progress.result.skipped_wave_count, 2);
assert.deepEqual(progress.result.skipped_wave_ids, [ 12, 13 ]);
assert.deepEqual(
progress.result.skipped_waves.map(item => item.reason),
[ 'wave_status_blocked', 'picked_orders_exist' ]
);
assert.deepEqual(state.canceledWaveIds, [ 11 ], '仅正常波次执行取消');
const deleteCall = state.sqlCalls.find(call => call.sql.includes('DELETE FROM wms_order_wave_index'));
assert.deepEqual(
deleteCall.options.replacements.waveIds.map(id => Number(id)),
[ 11 ]
);
assert.deepEqual(
state.orders.filter(order => [ 101, 102 ].includes(order.id)).map(order => order.wave_id),
[ 0, 0 ],
'正常波次订单应被移出波次'
);
assert.equal(state.orders.find(order => order.id === 103).wave_id, 12, '被跳过波次订单保持原波次');
assert.equal(state.orders.find(order => order.id === 104).wave_id, 13, '被跳过波次订单保持原波次');
});
});