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

256 lines
8.4 KiB
JavaScript

'use strict';
const assert = require('node:assert/strict');
const { Op } = require('sequelize');
const WaveService = require('../../../../../app/service/systemMethods/order/wave');
/**
* 创建 batchRemoveOrders 轻量测试上下文。
*
* @param {Object} options 初始化选项。
* @param {Array<Object>} options.orders 订单初始数据。
* @param {Array<Object>} options.waves 波次初始数据。
* @param {number} options.storeId 当前仓库ID。
* @return {{ service: WaveService, orders: Array<Object>, waves: Array<Object>, txState: Object }} 测试上下文。
*/
function createHarness({ orders = [], waves = [], storeId = 100000 } = {}) {
const orderStore = orders.map(row => ({ ...row }));
const waveStore = waves.map(row => ({ ...row }));
const txState = {
committed: false,
rolledBack: false,
};
const transaction = {
async commit() {
txState.committed = true;
},
async rollback() {
txState.rolledBack = true;
},
};
const ctx = {
app: {
config: {},
},
user: {
store_id: storeId,
},
model: {
QueryTypes: {
SELECT: 'SELECT',
},
fn(name, colName) {
return `${name}(${colName})`;
},
col(field) {
return field;
},
async transaction() {
return transaction;
},
async query(sql, options = {}) {
if (sql.includes('SET total_orders = :remainingCount')) {
const waveId = Number(options.replacements && options.replacements.waveId || 0);
const remainingCount = Number(options.replacements && options.replacements.remainingCount || 0);
const targetWave = waveStore.find(item => Number(item.wave_id) === waveId);
if (targetWave) {
targetWave.total_orders = remainingCount;
targetWave.processed_orders = Math.min(Number(targetWave.processed_orders || 0), remainingCount);
}
return [[], { affectedRows: targetWave ? 1 : 0 }];
}
if (sql.includes('SET total_orders = 0') && sql.includes('wave_status = -1')) {
const targetWaveIds = Array.isArray(options.replacements && options.replacements.waveIds)
? options.replacements.waveIds
: [];
for (const wave of waveStore) {
if (targetWaveIds.includes(wave.wave_id)) {
wave.total_orders = 0;
wave.processed_orders = 0;
wave.wave_status = -1;
}
}
return [[], { affectedRows: targetWaveIds.length }];
}
return [[], { affectedRows: 0 }];
},
},
};
const service = new WaveService(ctx);
service.getOrderModel = async () => ({
async findAll(options = {}) {
const where = options.where || {};
const idIn = (where.id && where.id[Op.in]) || [];
const stepIn = (where.step && where.step[Op.in]) || [];
const waveIn = (where.wave_id && where.wave_id[Op.in]) || [];
const waveGt = Number((where.wave_id && where.wave_id[Op.gt]) || 0);
if (Array.isArray(options.group) && options.group.includes('wave_id')) {
const result = [];
for (const waveId of waveIn) {
const count = orderStore.filter(item => Number(item.wave_id) === Number(waveId) && Number(item.wave_id) > waveGt).length;
if (count > 0) {
result.push({
wave_id: Number(waveId),
remaining_count: count,
});
}
}
return result;
}
return orderStore
.filter(item => idIn.includes(item.id))
.filter(item => stepIn.includes(item.step))
.filter(item => Number(item.wave_id) > waveGt)
.map(item => ({
id: item.id,
wave_id: item.wave_id,
}));
},
async update(values = {}, options = {}) {
const ids = (options.where && options.where.id && options.where.id[Op.in]) || [];
let affected = 0;
for (const item of orderStore) {
if (ids.includes(item.id)) {
item.wave_id = values.wave_id;
item.wave_no = values.wave_no;
affected += 1;
}
}
return [ affected ];
},
});
return {
service,
orders: orderStore,
waves: waveStore,
txState,
};
}
describe('test/app/service/systemMethods/order/wave.batchRemoveOrders.test.js', () => {
it('should only remove orders with step in [1,2,3]', async () => {
const { service, orders } = createHarness({
orders: [
{ id: 1, order_id: 101, step: 1, wave_id: 11, wave_no: 'W11' },
{ id: 2, order_id: 102, step: 2, wave_id: 11, wave_no: 'W11' },
{ id: 3, order_id: 103, step: 0, wave_id: 11, wave_no: 'W11' },
{ id: 4, order_id: 104, step: 3, wave_id: 12, wave_no: 'W12' },
],
waves: [
{ wave_id: 11, total_orders: 3, processed_orders: 2, wave_status: 1 },
{ wave_id: 12, total_orders: 1, processed_orders: 0, wave_status: 1 },
],
});
const result = await service.batchRemoveOrders({ ids: '1,2,3,4' });
assert.equal(result.flag, 'success');
assert.deepEqual(result.ids, [ 1, 2, 3, 4 ]);
assert.deepEqual(result.removed_order_ids, [ 1, 2, 4 ]);
assert.equal(result.removed_order_count, 3);
assert.deepEqual(result.affected_wave_ids, [ 11, 12 ]);
const orderWithStep0 = orders.find(item => item.id === 3);
assert.equal(orderWithStep0.wave_id, 11);
assert.equal(orderWithStep0.wave_no, 'W11');
});
it('should update orders and wave stats in one transaction', async () => {
const { service, orders, waves, txState } = createHarness({
orders: [
{ id: 10, order_id: 110, step: 1, wave_id: 21, wave_no: 'W21' },
{ id: 11, order_id: 111, step: 2, wave_id: 21, wave_no: 'W21' },
{ id: 12, order_id: 112, step: 0, wave_id: 21, wave_no: 'W21' },
{ id: 13, order_id: 113, step: 1, wave_id: 22, wave_no: 'W22' },
],
waves: [
{ wave_id: 21, total_orders: 3, processed_orders: 5, wave_status: 1 },
{ wave_id: 22, total_orders: 1, processed_orders: 1, wave_status: 1 },
],
});
const result = await service.batchRemoveOrders({ ids: [ 10, 11, 13 ] });
assert.equal(txState.committed, true);
assert.equal(txState.rolledBack, false);
assert.equal(result.removed_order_count, 3);
assert.deepEqual(result.updated_wave_ids, [ 21 ]);
assert.deepEqual(result.emptied_wave_ids, [ 22 ]);
const removedOrder = orders.find(item => item.id === 10);
assert.equal(removedOrder.wave_id, 0);
assert.equal(removedOrder.wave_no, '');
const updatedWave = waves.find(item => item.wave_id === 21);
assert.equal(updatedWave.total_orders, 1);
assert.equal(updatedWave.processed_orders, 1);
assert.equal(updatedWave.wave_status, 1);
const emptiedWave = waves.find(item => item.wave_id === 22);
assert.equal(emptiedWave.total_orders, 0);
assert.equal(emptiedWave.processed_orders, 0);
assert.equal(emptiedWave.wave_status, -1);
});
it('should accept order_ids alias and normalize ids in response', async () => {
const { service } = createHarness({
orders: [
{ id: 21, order_id: 121, step: 1, wave_id: 31, wave_no: 'W31' },
{ id: 22, order_id: 122, step: 2, wave_id: 31, wave_no: 'W31' },
],
waves: [
{ wave_id: 31, total_orders: 2, processed_orders: 1, wave_status: 1 },
],
});
const result = await service.batchRemoveOrders({ order_ids: '21,22' });
assert.equal(result.flag, 'success');
assert.deepEqual(result.ids, [ 21, 22 ]);
});
it('should work when pendingOrder has no order_id column', async () => {
const { service, orders } = createHarness({
orders: [
{ id: 31, step: 1, wave_id: 41, wave_no: 'W41' },
{ id: 32, step: 2, wave_id: 41, wave_no: 'W41' },
],
waves: [
{ wave_id: 41, total_orders: 2, processed_orders: 1, wave_status: 1 },
],
});
const result = await service.batchRemoveOrders({ ids: [ 31, 32 ] });
assert.equal(result.flag, 'success');
assert.deepEqual(result.removed_order_ids, [ 31, 32 ]);
assert.equal(result.removed_order_count, 2);
assert.equal(orders[0].wave_id, 0);
assert.equal(orders[1].wave_id, 0);
});
it('should throw when ids is empty', async () => {
const { service } = createHarness({
orders: [],
waves: [],
});
await assert.rejects(
async () => service.batchRemoveOrders({ ids: '' }),
/ids 参数不能为空或格式错误/
);
});
});