522 lines
18 KiB
JavaScript
522 lines
18 KiB
JavaScript
'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, '被跳过波次订单保持原波次');
|
||
});
|
||
});
|