256 lines
8.4 KiB
JavaScript
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 参数不能为空或格式错误/
|
|
);
|
|
});
|
|
});
|