WMS_MAIN/test/app/controller/system.order.badgeCount.test.js
2026-04-17 19:21:57 +08:00

173 lines
4.9 KiB
JavaScript

'use strict';
const assert = require('node:assert/strict');
const OrderIndexService = require('../../../app/service/systemMethods/order/index');
const { buildRows, createOrderHarness, matchesWhere } = require('../../support/order_service_test_helper');
function createBadgeCountHarness(rowsByModule = {}) {
const { service, captures } = createOrderHarness(OrderIndexService, {
rowsByModule,
});
const cacheStore = new Map();
const cacheStats = {
getCalls: 0,
setCalls: 0,
};
service.app.getCacheAsync = async cacheKey => {
cacheStats.getCalls += 1;
if (!cacheStore.has(cacheKey)) {
return null;
}
return cacheStore.get(cacheKey);
};
service.app.setCacheAsync = async (cacheKey, value) => {
cacheStats.setCalls += 1;
cacheStore.set(cacheKey, value);
};
return {
service,
captures,
cacheStats,
};
}
describe('test/app/controller/system.order.badgeCount.test.js', () => {
it('should return 8 badge fields and keep delivery/archive as 99+', async () => {
const { service, captures } = createBadgeCountHarness({
reviewOrder: buildRows(99, () => ({
step: 0,
dispatch_lane: 'm4',
})),
pendingOrder: buildRows(100, () => ({
step: 1,
outbound_status: 'none',
dispatch_lane: 'm4',
})),
outboundOrder: buildRows(1, () => ({
step: 1,
outbound_status: 'padding',
dispatch_lane: 'm4',
})),
expectionOrder: buildRows(2, () => ({
step: 3,
dispatch_lane: 'm4',
})),
entrustOrder: buildRows(1, () => ({
step: 1,
dispatch_lane: 'm4',
})),
});
const result = await service.badgeCount();
assert.deepEqual(Object.keys(result), [
'reviewOrder',
'pendingOrder',
'outboundOrder',
'expectionOrder',
'entrustOrder',
'deliveryOrder',
'deliveryExpectionOrder',
'archiveOrder',
]);
assert.equal(result.reviewOrder, 99);
assert.equal(result.pendingOrder, '99+');
assert.equal(result.outboundOrder, 1);
assert.equal(result.expectionOrder, 2);
assert.equal(result.entrustOrder, 1);
assert.equal(result.deliveryOrder, '99+');
assert.equal(result.deliveryExpectionOrder, '99+');
assert.equal(result.archiveOrder, '99+');
assert.deepEqual(captures.map(item => item.moduleName), [
'reviewOrder',
'pendingOrder',
'outboundOrder',
'expectionOrder',
'entrustOrder',
]);
assert.ok(matchesWhere({ warehouse_id: 100000, step: 0 }, captures[0].countWhere));
assert.ok(matchesWhere({ warehouse_id: 100000, step: 1, outbound_status: 'none' }, captures[1].countWhere));
assert.ok(matchesWhere({ warehouse_id: 100000, step: 1, outbound_status: 'padding' }, captures[2].countWhere));
assert.ok(matchesWhere({ warehouse_id: 100000, step: 3 }, captures[3].countWhere));
assert.ok(matchesWhere({ warehouse_id: 100000 }, captures[4].countWhere));
});
it('should use cache and avoid repeated count queries', async () => {
const { service, captures, cacheStats } = createBadgeCountHarness({
reviewOrder: buildRows(2, () => ({
step: 0,
dispatch_lane: 'm4',
})),
pendingOrder: buildRows(2, () => ({
step: 1,
outbound_status: 'none',
dispatch_lane: 'm4',
})),
outboundOrder: buildRows(2, () => ({
step: 1,
outbound_status: 'none',
dispatch_lane: 'm4',
})),
expectionOrder: buildRows(1, () => ({
step: 3,
dispatch_lane: 'm4',
})),
entrustOrder: buildRows(1, () => ({
step: 1,
dispatch_lane: 'm4',
})),
});
const firstResult = await service.badgeCount();
const firstCaptureCount = captures.length;
const secondResult = await service.badgeCount();
assert.deepEqual(secondResult, firstResult);
assert.equal(captures.length, firstCaptureCount);
assert.equal(cacheStats.setCalls, 1);
assert.equal(cacheStats.getCalls, 2);
});
it('should keep exact counts within 99 and convert larger counts to 99+', async () => {
const { service } = createBadgeCountHarness({
reviewOrder: buildRows(1, () => ({
step: 0,
dispatch_lane: 'm4',
})),
pendingOrder: buildRows(100, () => ({
step: 1,
outbound_status: 'none',
dispatch_lane: 'm4',
})),
outboundOrder: buildRows(99, () => ({
step: 1,
outbound_status: 'none',
dispatch_lane: 'm4',
})),
expectionOrder: buildRows(3, () => ({
step: 3,
dispatch_lane: 'm4',
})),
entrustOrder: buildRows(1, () => ({
step: 1,
dispatch_lane: 'm4',
})),
});
const result = await service.badgeCount();
assert.equal(result.reviewOrder, 1);
assert.equal(result.pendingOrder, '99+');
assert.equal(result.outboundOrder, 99);
assert.equal(result.expectionOrder, 3);
assert.equal(result.entrustOrder, 1);
});
});