328 lines
13 KiB
JavaScript
328 lines
13 KiB
JavaScript
import {
|
|
BASE_REVENUE,
|
|
BASE_KM_LIMIT,
|
|
EXTRA_RATE_KM,
|
|
FIXED_COST_PER_SLOT,
|
|
VARIABLE_RATE_KM,
|
|
rowDay,
|
|
calcRiderMetrics,
|
|
groupRowsByRider
|
|
} from '@/lib/profitability';
|
|
|
|
/**
|
|
* The unit economics of a delivery day. Every figure the Profitability report
|
|
* shows comes from here, so the headline and the table underneath it cannot
|
|
* disagree.
|
|
*
|
|
* The behaviours worth protecting, in order of how much money they move:
|
|
* 1. Cancelled/skipped stops earn nothing AND cost nothing.
|
|
* 2. Slot count (which drives fixed cost) is derived from `orderdate`, never
|
|
* `assigntime` — the latter is re-stamped by any status change.
|
|
* 3. A bare date has no slot, because midnight would otherwise be assumed.
|
|
*/
|
|
const order = (over = {}) => ({ orderdate: '2026-08-27T07:00:00', riderkms: 5, orderstatus: 'delivered', ...over });
|
|
|
|
describe('profitability', () => {
|
|
describe('the published rate card', () => {
|
|
it('should charge a 30 rupee base for the first 8 km, then 6/km', () => {
|
|
expect(BASE_REVENUE).toBe(30);
|
|
expect(BASE_KM_LIMIT).toBe(8);
|
|
expect(EXTRA_RATE_KM).toBe(6);
|
|
});
|
|
|
|
it('should slice a 500 rupee salary across three slots', () => {
|
|
expect(FIXED_COST_PER_SLOT).toBeCloseTo(500 / 3, 10);
|
|
expect(VARIABLE_RATE_KM).toBe(2.5);
|
|
});
|
|
});
|
|
|
|
describe('rowDay', () => {
|
|
it('should return the creation day of a booking', () => {
|
|
expect(rowDay({ orderdate: '2026-08-27T07:00:00' })).toBe('2026-08-27');
|
|
});
|
|
|
|
it('should strip a false trailing Z so a late order stays on its own day', () => {
|
|
expect(rowDay({ orderdate: '2026-08-27T23:30:00Z' })).toBe('2026-08-27');
|
|
});
|
|
|
|
it.each([{}, { orderdate: null }, { orderdate: '' }, { orderdate: 'garbage' }])(
|
|
'should return null for the unusable row %p',
|
|
(row) => {
|
|
expect(rowDay(row)).toBeNull();
|
|
}
|
|
);
|
|
|
|
it('should not throw on a null row', () => {
|
|
expect(rowDay(null)).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe('calcRiderMetrics — revenue', () => {
|
|
it('should charge only the base fare for a stop inside the base km limit', () => {
|
|
const metrics = calcRiderMetrics({ orders: [order({ riderkms: 5 })] }, '2026-08-27');
|
|
expect(metrics.revenue).toBe(30);
|
|
});
|
|
|
|
it('should charge only the base fare at exactly the base km limit', () => {
|
|
// Boundary: 8 km is inclusive of the base fare, 8.01 is not.
|
|
expect(calcRiderMetrics({ orders: [order({ riderkms: 8 })] }, '2026-08-27').revenue).toBe(30);
|
|
});
|
|
|
|
it('should add the per-km rate beyond the base limit', () => {
|
|
// 12 km => 30 + (12 - 8) * 6 = 54
|
|
expect(calcRiderMetrics({ orders: [order({ riderkms: 12 })] }, '2026-08-27').revenue).toBe(54);
|
|
});
|
|
|
|
it('should accept riderkms as a numeric string, as the API returns it', () => {
|
|
expect(calcRiderMetrics({ orders: [order({ riderkms: '12' })] }, '2026-08-27').revenue).toBe(54);
|
|
});
|
|
|
|
it.each([null, undefined, '', 'abc', NaN])(
|
|
'should treat the unusable distance %p as zero km and still charge the base fare',
|
|
(riderkms) => {
|
|
const metrics = calcRiderMetrics({ orders: [order({ riderkms })] }, '2026-08-27');
|
|
expect(metrics.revenue).toBe(30);
|
|
expect(metrics.kms).toBe(0);
|
|
}
|
|
);
|
|
|
|
it('should sum revenue across every billable stop', () => {
|
|
const metrics = calcRiderMetrics(
|
|
{ orders: [order({ riderkms: 5 }), order({ riderkms: 12 })] },
|
|
'2026-08-27'
|
|
);
|
|
expect(metrics.revenue).toBe(84);
|
|
expect(metrics.kms).toBe(17);
|
|
});
|
|
});
|
|
|
|
describe('calcRiderMetrics — exclusions', () => {
|
|
it.each(['cancelled', 'canceled', 'skipped', 'CANCELLED', 'Skipped'])(
|
|
'should exclude a %s stop from revenue, km and slot cost',
|
|
(orderstatus) => {
|
|
const metrics = calcRiderMetrics(
|
|
{ orders: [order({ orderstatus, riderkms: 20 })] },
|
|
'2026-08-27'
|
|
);
|
|
expect(metrics.revenue).toBe(0);
|
|
expect(metrics.kms).toBe(0);
|
|
expect(metrics.slotCount).toBe(0);
|
|
expect(metrics.totalCost).toBe(0);
|
|
}
|
|
);
|
|
|
|
it('should still list an excluded stop in `orders` for the breakdown table', () => {
|
|
// The table deliberately shows cancelled stops for context; only the money
|
|
// excludes them.
|
|
const metrics = calcRiderMetrics(
|
|
{ orders: [order({ orderstatus: 'cancelled' }), order()] },
|
|
'2026-08-27'
|
|
);
|
|
expect(metrics.orders).toHaveLength(2);
|
|
expect(metrics.billable).toHaveLength(1);
|
|
});
|
|
|
|
it('should read `status` when `orderstatus` is absent', () => {
|
|
const metrics = calcRiderMetrics(
|
|
{ orders: [{ orderdate: '2026-08-27T07:00:00', riderkms: 5, status: 'cancelled' }] },
|
|
'2026-08-27'
|
|
);
|
|
expect(metrics.revenue).toBe(0);
|
|
});
|
|
|
|
it('should treat a stop with no status at all as billable', () => {
|
|
const metrics = calcRiderMetrics(
|
|
{ orders: [{ orderdate: '2026-08-27T07:00:00', riderkms: 5 }] },
|
|
'2026-08-27'
|
|
);
|
|
expect(metrics.revenue).toBe(30);
|
|
});
|
|
});
|
|
|
|
describe('calcRiderMetrics — slots and fixed cost', () => {
|
|
it('should charge one slot when every stop falls in the same wave', () => {
|
|
const metrics = calcRiderMetrics(
|
|
{ orders: [order({ orderdate: '2026-08-27T07:00:00' }), order({ orderdate: '2026-08-27T08:30:00' })] },
|
|
'2026-08-27'
|
|
);
|
|
expect(metrics.slotCount).toBe(1);
|
|
expect(metrics.fixedCost).toBeCloseTo(FIXED_COST_PER_SLOT, 6);
|
|
});
|
|
|
|
it('should charge one slot per distinct wave worked', () => {
|
|
const metrics = calcRiderMetrics(
|
|
{
|
|
orders: [
|
|
order({ orderdate: '2026-08-27T07:00:00' }),
|
|
order({ orderdate: '2026-08-27T11:00:00' }),
|
|
order({ orderdate: '2026-08-27T18:00:00' })
|
|
]
|
|
},
|
|
'2026-08-27'
|
|
);
|
|
expect(metrics.slotCount).toBe(3);
|
|
expect(metrics.fixedCost).toBeCloseTo(500, 6);
|
|
});
|
|
|
|
it('should never charge more than three slots for a single day', () => {
|
|
const orders = Array.from({ length: 12 }, (_, i) =>
|
|
order({ orderdate: `2026-08-27T${String(i * 2).padStart(2, '0')}:00:00` })
|
|
);
|
|
expect(calcRiderMetrics({ orders }, '2026-08-27').slotCount).toBe(3);
|
|
});
|
|
|
|
it('should charge no slot for a bare date, which has no time component', () => {
|
|
// Otherwise every date-only row would silently bill a Morning slot.
|
|
const metrics = calcRiderMetrics({ orders: [order({ orderdate: '2026-08-27' })] }, '2026-08-27');
|
|
expect(metrics.slotCount).toBe(0);
|
|
expect(metrics.fixedCost).toBe(0);
|
|
expect(metrics.revenue).toBe(30);
|
|
});
|
|
|
|
it('should charge no slot for an unparseable orderdate', () => {
|
|
const metrics = calcRiderMetrics({ orders: [order({ orderdate: 'garbage' })] }, undefined);
|
|
expect(metrics.slotCount).toBe(0);
|
|
});
|
|
|
|
it('should ignore assigntime, which is re-stamped by any status change', () => {
|
|
// Reading assigntime made a rider's slot count — and therefore their
|
|
// fixed cost — drift through the day.
|
|
const metrics = calcRiderMetrics(
|
|
{ orders: [order({ orderdate: '2026-08-27T07:00:00', assigntime: '2026-08-27T19:00:00' })] },
|
|
'2026-08-27'
|
|
);
|
|
expect(metrics.slotCount).toBe(1);
|
|
expect(metrics.fixedCost).toBeCloseTo(FIXED_COST_PER_SLOT, 6);
|
|
});
|
|
|
|
it('should charge slots per day when no date filter is applied', () => {
|
|
const metrics = calcRiderMetrics({
|
|
orders: [order({ orderdate: '2026-08-26T07:00:00' }), order({ orderdate: '2026-08-27T07:00:00' })]
|
|
});
|
|
expect(metrics.slotCount).toBe(2);
|
|
});
|
|
});
|
|
|
|
describe('calcRiderMetrics — cost, net and margin', () => {
|
|
it('should compute the full P&L for a two-wave day', () => {
|
|
const metrics = calcRiderMetrics(
|
|
{
|
|
orders: [
|
|
order({ orderdate: '2026-08-27T07:00:00', riderkms: 5 }),
|
|
order({ orderdate: '2026-08-27T10:00:00', riderkms: 10 })
|
|
]
|
|
},
|
|
'2026-08-27'
|
|
);
|
|
|
|
expect(metrics.revenue).toBe(72); // 30 + (30 + 2*6)
|
|
expect(metrics.kms).toBe(15);
|
|
expect(metrics.slotCount).toBe(2);
|
|
expect(metrics.varCost).toBeCloseTo(37.5, 6); // 15 * 2.5
|
|
expect(metrics.fixedCost).toBeCloseTo((500 / 3) * 2, 6);
|
|
expect(metrics.totalCost).toBeCloseTo(37.5 + (500 / 3) * 2, 6);
|
|
expect(metrics.net).toBeCloseTo(72 - (37.5 + (500 / 3) * 2), 6);
|
|
expect(metrics.margin).toBeCloseTo((metrics.net / 72) * 100, 6);
|
|
});
|
|
|
|
it('should report a zero margin — not NaN or Infinity — when there is no revenue', () => {
|
|
const metrics = calcRiderMetrics({ orders: [] }, '2026-08-27');
|
|
expect(metrics.revenue).toBe(0);
|
|
expect(metrics.margin).toBe(0);
|
|
expect(Number.isFinite(metrics.margin)).toBe(true);
|
|
});
|
|
|
|
it('should report a negative net when cost exceeds revenue', () => {
|
|
const metrics = calcRiderMetrics({ orders: [order({ riderkms: 1 })] }, '2026-08-27');
|
|
expect(metrics.net).toBeLessThan(0);
|
|
expect(metrics.margin).toBeLessThan(0);
|
|
});
|
|
|
|
it('should keep net equal to revenue minus total cost', () => {
|
|
const metrics = calcRiderMetrics(
|
|
{ orders: [order({ riderkms: 30 }), order({ orderdate: '2026-08-27T17:00:00', riderkms: 4 })] },
|
|
'2026-08-27'
|
|
);
|
|
expect(metrics.net).toBeCloseTo(metrics.revenue - metrics.totalCost, 9);
|
|
expect(metrics.totalCost).toBeCloseTo(metrics.varCost + metrics.fixedCost, 9);
|
|
});
|
|
});
|
|
|
|
describe('calcRiderMetrics — date filtering and empty input', () => {
|
|
it('should count only the selected day when a date is given', () => {
|
|
const metrics = calcRiderMetrics(
|
|
{ orders: [order({ orderdate: '2026-08-26T07:00:00' }), order({ orderdate: '2026-08-27T07:00:00' })] },
|
|
'2026-08-27'
|
|
);
|
|
expect(metrics.orders).toHaveLength(1);
|
|
expect(metrics.revenue).toBe(30);
|
|
});
|
|
|
|
it('should count every day when no date is given', () => {
|
|
const metrics = calcRiderMetrics({
|
|
orders: [order({ orderdate: '2026-08-26T07:00:00' }), order({ orderdate: '2026-08-27T07:00:00' })]
|
|
});
|
|
expect(metrics.orders).toHaveLength(2);
|
|
});
|
|
|
|
it('should return an all-zero result for a rider with no orders array', () => {
|
|
const metrics = calcRiderMetrics({}, '2026-08-27');
|
|
expect(metrics).toMatchObject({ revenue: 0, kms: 0, slotCount: 0, totalCost: 0, net: 0, margin: 0 });
|
|
expect(metrics.orders).toEqual([]);
|
|
});
|
|
|
|
it('should exclude a stop whose day cannot be determined when a date is selected', () => {
|
|
const metrics = calcRiderMetrics({ orders: [order({ orderdate: 'garbage' })] }, '2026-08-27');
|
|
expect(metrics.orders).toHaveLength(0);
|
|
expect(metrics.revenue).toBe(0);
|
|
});
|
|
});
|
|
|
|
describe('groupRowsByRider', () => {
|
|
const row = (over = {}) => ({ userid: 7, ridername: 'Anita', kms: 5, ...over });
|
|
|
|
it('should group every row belonging to the same rider', () => {
|
|
const riders = groupRowsByRider([row(), row({ kms: 9 })]);
|
|
expect(riders).toHaveLength(1);
|
|
expect(riders[0]).toMatchObject({ id: '7', riderName: 'Anita' });
|
|
expect(riders[0].orders).toHaveLength(2);
|
|
});
|
|
|
|
it('should map the row `kms` onto `riderkms`, which the money math reads', () => {
|
|
// A booking carries no road distance, so the straight-line proxy feeds the
|
|
// rate card. If this mapping breaks, every rider silently earns base fare.
|
|
const [rider] = groupRowsByRider([row({ kms: 12 })]);
|
|
expect(rider.orders[0].riderkms).toBe(12);
|
|
expect(calcRiderMetrics(rider).revenue).toBe(54);
|
|
});
|
|
|
|
it('should treat numeric and string user ids as the same rider', () => {
|
|
expect(groupRowsByRider([row({ userid: 7 }), row({ userid: '7' })])).toHaveLength(1);
|
|
});
|
|
|
|
it('should drop rows with no userid, which cannot be attributed to anyone', () => {
|
|
expect(groupRowsByRider([row({ userid: null }), row({ userid: undefined }), row()])).toHaveLength(1);
|
|
});
|
|
|
|
it('should fall back to a numbered placeholder when the rider has no name', () => {
|
|
const [rider] = groupRowsByRider([row({ ridername: null })]);
|
|
expect(rider.riderName).toBe('Rider #7');
|
|
});
|
|
|
|
it('should keep the first-seen name for a rider whose later rows are unnamed', () => {
|
|
const [rider] = groupRowsByRider([row({ ridername: 'Anita' }), row({ ridername: null })]);
|
|
expect(rider.riderName).toBe('Anita');
|
|
});
|
|
|
|
it.each([[[]], [null], [undefined]])('should return an empty list for %p', (rows) => {
|
|
expect(groupRowsByRider(rows)).toEqual([]);
|
|
});
|
|
|
|
it('should not mutate the caller rows', () => {
|
|
const source = row();
|
|
groupRowsByRider([source]);
|
|
expect(source).not.toHaveProperty('riderkms');
|
|
});
|
|
});
|
|
});
|