173 lines
4.9 KiB
JavaScript
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);
|
|
});
|
|
});
|