WMS_MAIN/test/app/controller/system.order.reviewOrder.test.js
2026-04-27 16:09:26 +08:00

356 lines
10 KiB
JavaScript

'use strict';
const assert = require('node:assert/strict');
const Sequelize = require('sequelize');
const ReviewOrderService = require('../../../app/service/systemMethods/order/reviewOrder');
const PendingOrderService = require('../../../app/service/systemMethods/order/pendingOrder');
const { buildRows, createOrderHarness, matchesWhere } = require('../../support/order_service_test_helper');
/**
* 创建支持更新结果回写的订单模型。
* @param {Array<Object>} rows 初始订单数据。
* @param {Object} capture 调用信息。
* @return {Object} 模拟模型。
*/
function createMutableOrderModel(rows, capture = {}) {
const storedRows = Array.isArray(rows) ? rows.map(row => ({ ...row })) : [];
capture.rows = storedRows;
return {
async count({ where } = {}) {
capture.countWhere = where;
return storedRows.filter(row => matchesWhere(row, where)).length;
},
async update(values = {}, options = {}) {
capture.updateValues = { ...values };
capture.updateWhere = options.where;
const matchedRows = storedRows.filter(row => matchesWhere(row, options.where));
for (const row of matchedRows) {
Object.assign(row, values);
}
return [ matchedRows.length ];
},
async findAll(options = {}) {
capture.findAllWhere = options.where;
return storedRows
.filter(row => matchesWhere(row, options.where))
.map(row => ({ ...row }));
},
async findOne(options = {}) {
capture.findOneWhere = options.where;
const matchedRow = storedRows.find(row => matchesWhere(row, options.where));
return matchedRow ? { ...matchedRow } : null;
},
};
}
/**
* 创建共享同一份行数组的订单模型。
* @param {Array<Object>} rows 共享订单数据。
* @param {Object} capture 调用信息。
* @return {Object} 模拟模型。
*/
function createSharedMutableOrderModel(rows, capture = {}) {
const storedRows = Array.isArray(rows) ? rows : [];
capture.rows = storedRows;
return {
async count({ where } = {}) {
capture.countWhere = where;
return storedRows.filter(row => matchesWhere(row, where)).length;
},
async update(values = {}, options = {}) {
capture.updateValues = { ...values };
capture.updateWhere = options.where;
const matchedRows = storedRows.filter(row => matchesWhere(row, options.where));
for (const row of matchedRows) {
Object.assign(row, values);
}
return [ matchedRows.length ];
},
async findAll(options = {}) {
capture.findAllWhere = options.where;
return storedRows
.filter(row => matchesWhere(row, options.where))
.map(row => ({ ...row }));
},
async findOne(options = {}) {
capture.findOneWhere = options.where;
const matchedRow = storedRows.find(row => matchesWhere(row, options.where));
return matchedRow ? { ...matchedRow } : null;
},
};
}
/**
* 创建共享数据的分页模型。
* @param {Array<Object>} rows 共享订单数据。
* @param {Object} capture 调用信息。
* @return {Object} 模拟模型。
*/
function createSharedPagedOrderModel(rows, capture = {}) {
const storedRows = Array.isArray(rows) ? rows : [];
capture.rows = storedRows;
return {
async count({ where } = {}) {
capture.countWhere = where;
return storedRows.filter(row => matchesWhere(row, where)).length;
},
async findAll(options = {}) {
capture.findAllWhere = options.where;
return storedRows
.filter(row => matchesWhere(row, options.where))
.map(row => ({ ...row }));
},
};
}
/**
* 创建审核服务测试实例。
* @param {Array<Object>} rows 初始订单数据。
* @return {{ service: ReviewOrderService, capture: Object }} 服务与调用记录。
*/
function createReviewOrderService(rows) {
const { service } = createOrderHarness(ReviewOrderService, {
defaultRows: rows,
});
const capture = {};
service.getOrderModel = async () => createMutableOrderModel(rows, capture);
return {
service,
capture,
};
}
/**
* 创建共享数据的待处理订单服务实例。
* @param {Array<Object>} rows 共享订单数据。
* @return {{ service: PendingOrderService, capture: Object }} 服务与调用记录。
*/
function createPendingOrderService(rows) {
const { service } = createOrderHarness(PendingOrderService, {
defaultRows: rows,
});
const capture = {};
service.getOrderModel = async () => createSharedPagedOrderModel(rows, capture);
return {
service,
capture,
};
}
/**
* 创建共享数据的审核服务实例。
* @param {Array<Object>} rows 共享订单数据。
* @return {{ service: ReviewOrderService, capture: Object }} 服务与调用记录。
*/
function createSharedReviewOrderService(rows) {
const { service } = createOrderHarness(ReviewOrderService, {
defaultRows: rows,
});
const capture = {};
service.getOrderModel = async () => createSharedMutableOrderModel(rows, capture);
return {
service,
capture,
};
}
describe('test/app/controller/system.order.reviewOrder.test.js', () => {
it('should return list/pagination for reviewOrder.list', async () => {
const { service, captures } = createOrderHarness(ReviewOrderService, {
rowsByModule: {
reviewOrder: buildRows(1, () => ({
step: 0,
dispatch_lane: 'm4',
weight_type: 1,
})),
},
});
const result = await service.list({
pagination: {
page: 1,
pageSize: 1,
},
where: {},
});
assert.equal(captures[0].moduleName, 'reviewOrder');
assert.ok(Array.isArray(result.list));
assert.ok(result.pagination);
assert.equal(result.pagination.page, 1);
assert.equal(result.pagination.pageSize, 1);
assert.equal(result.list.length, 1);
assert.equal(result.list[0].weight_type, '轻货');
});
it('should update batch orders by ids and force review approval status', async () => {
const { service, capture } = createReviewOrderService(buildRows(3, index => ({
id: index + 1,
warehouse_id: 100000,
step: 0,
inspection_status: 'none',
order_flag: '待清理异常标记',
updated_at: '2026-04-12 00:00:00',
})));
const result = await service.reviewOrder({
ids: [ 1, 3 ],
});
assert.equal(capture.updateWhere.warehouse_id, 100000);
assert.equal(capture.updateWhere.id[Sequelize.Op.in].length, 2);
assert.ok(matchesWhere({ id: 1, warehouse_id: 100000 }, capture.updateWhere));
assert.ok(!matchesWhere({ id: 2, warehouse_id: 100000 }, capture.updateWhere));
assert.ok(matchesWhere({ id: 3, warehouse_id: 100000 }, capture.updateWhere));
assert.equal(capture.updateValues.inspection_status, 'fin');
assert.equal(capture.updateValues.step, 1);
assert.equal(capture.updateValues.order_flag, undefined);
assert.equal(result.id, 1);
assert.equal(result.inspection_status, 'fin');
assert.equal(result.step, 1);
assert.equal(result.updated_count, 2);
assert.deepEqual(result.ids, [ 1, 3 ]);
assert.equal(capture.rows.find(row => row.id === 1).inspection_status, 'fin');
assert.equal(capture.rows.find(row => row.id === 3).inspection_status, 'fin');
});
it('should reject empty ids', async () => {
const { service } = createReviewOrderService(buildRows(1, () => ({
id: 1,
warehouse_id: 100000,
step: 0,
inspection_status: 'none',
updated_at: '2026-04-12 00:00:00',
})));
await assert.rejects(
async () => await service.reviewOrder({
ids: [],
}),
/订单ID不能为空/
);
});
it('should reject legacy review fields and warehouse bypass fields', async () => {
const { service } = createReviewOrderService(buildRows(1, () => ({
id: 1,
warehouse_id: 100000,
step: 0,
inspection_status: 'none',
updated_at: '2026-04-12 00:00:00',
})));
const invalidPayloads = [
{ id: 1 },
{ order_id: 1 },
{ ids: [ 1 ], review_status: 'fin' },
{ ids: [ 1 ], inspection_status: 'fin' },
{ ids: [ 1 ], warehouse_id: 100000 },
{ ids: [ 1 ], warehouseId: 100000 },
];
for (const payload of invalidPayloads) {
await assert.rejects(
async () => await service.reviewOrder(payload),
/仅支持 ids 入参/
);
}
});
it('should reject orders outside current warehouse', async () => {
const { service, capture } = createReviewOrderService([
{
id: 1,
warehouse_id: 100000,
step: 0,
inspection_status: 'none',
updated_at: '2026-04-12 00:00:00',
},
{
id: 2,
warehouse_id: 200000,
step: 0,
inspection_status: 'none',
updated_at: '2026-04-12 00:00:00',
},
]);
await assert.rejects(
async () => await service.reviewOrder({
ids: [ 1, 2 ],
}),
/不属于当前仓库/
);
assert.equal(capture.updateValues, undefined);
});
it('should move approved orders from review list to pending list', async () => {
const sharedRows = buildRows(2, index => ({
id: index + 1,
warehouse_id: 100000,
step: 0,
inspection_status: 'none',
updated_at: '2026-04-12 00:00:00',
}));
const { service: reviewService } = createSharedReviewOrderService(sharedRows);
const { service: pendingService } = createPendingOrderService(sharedRows);
const reviewBefore = await reviewService.list({
pagination: {
page: 1,
pageSize: 10,
},
where: {},
});
const pendingBefore = await pendingService.list({
pagination: {
page: 1,
pageSize: 10,
},
where: {},
});
assert.equal(reviewBefore.list.length, 2);
assert.equal(pendingBefore.list.length, 0);
const result = await reviewService.reviewOrder({
ids: [ 1, 2 ],
});
const reviewAfter = await reviewService.list({
pagination: {
page: 1,
pageSize: 10,
},
where: {},
});
const pendingAfter = await pendingService.list({
pagination: {
page: 1,
pageSize: 10,
},
where: {},
});
assert.equal(result.step, 1);
assert.deepEqual(result.ids, [ 1, 2 ]);
assert.equal(reviewAfter.list.length, 0);
assert.deepEqual(pendingAfter.list.map(item => item.id), [ 1, 2 ]);
assert.ok(pendingAfter.list.every(item => [ 1, 2 ].includes(Number(item.step))));
});
});