mirror of
https://github.com/Tria-plc/edr-platform.git
synced 2026-08-28 05:30:55 +00:00
446 lines
14 KiB
TypeScript
446 lines
14 KiB
TypeScript
import { Booking } from '../bookings/entities/booking.entity';
|
||
import { WagonType } from '../wagon-types/entities/wagon-type.entity';
|
||
import {
|
||
applyWagonOrderReversal,
|
||
planWagonsWithStock,
|
||
} from './wagon-plan-flex.util';
|
||
import type { WagonPlanSlot } from './wagon-plan.util';
|
||
|
||
const nw6: WagonType = {
|
||
id: 'wt-nw6',
|
||
code: 'NW6',
|
||
name: 'Flat Wagon',
|
||
capacityTons: 70,
|
||
lengthMeters: 14,
|
||
supportedLoadTypes: ['CONTAINER'],
|
||
isActive: true,
|
||
supportsContainer: true,
|
||
} as WagonType;
|
||
|
||
const cw3: WagonType = {
|
||
id: 'wt-cw3',
|
||
code: 'CW3',
|
||
name: 'Covered Wagon',
|
||
capacityTons: 60,
|
||
lengthMeters: 14,
|
||
supportedLoadTypes: ['BULK'],
|
||
isActive: true,
|
||
supportsContainer: false,
|
||
} as WagonType;
|
||
|
||
const containerBooking = (id: string, quantity: number, wagonsRequired: number): Booking =>
|
||
({
|
||
id,
|
||
reference: id,
|
||
freightType: 'CONTAINER',
|
||
cargoTotalWeightVgm: quantity * 25,
|
||
bookingContainers: [
|
||
{
|
||
id: `${id}-line-0`,
|
||
containerTypeId: 'ct-1',
|
||
quantity,
|
||
wagonsRequired,
|
||
vgmPerUnitTons: 25,
|
||
},
|
||
],
|
||
}) as Booking;
|
||
|
||
describe('planWagonsWithStock — shortage detail', () => {
|
||
it('defers with a structured per-type shortage when container stock runs out', () => {
|
||
const result = planWagonsWithStock({
|
||
bookings: [containerBooking('BKG-1', 2, 1)],
|
||
allowed: {
|
||
byContainerTypeId: new Map([['ct-1', [nw6]]]),
|
||
byCargoTypeId: new Map(),
|
||
},
|
||
stock: {
|
||
mode: 'YARD',
|
||
remainingByTypeId: new Map([[nw6.id, 0]]),
|
||
codesByTypeId: new Map([[nw6.id, nw6.code]]),
|
||
},
|
||
});
|
||
|
||
expect(result.fitting).toHaveLength(0);
|
||
expect(result.deferred).toHaveLength(1);
|
||
const row = result.deferred[0]!;
|
||
expect(row.reference).toBe('BKG-1');
|
||
expect(row.reason).toContain('No available NW6 wagon at the yard');
|
||
expect(row.reason).toContain('short 1');
|
||
expect(row.shortage).toEqual({
|
||
wagonTypeCodes: 'NW6',
|
||
wagonsNeeded: 1,
|
||
wagonsAvailable: 0,
|
||
wagonsShort: 1,
|
||
});
|
||
});
|
||
|
||
it('counts the stock the deferred booking actually saw, not its rolled-back usage', () => {
|
||
// Two wagons needed (2 × 40ft), one in stock: booking rolls back entirely,
|
||
// the shortage reports 1 available / 1 short.
|
||
const fortyFooter = containerBooking('BKG-2', 2, 2);
|
||
fortyFooter.bookingContainers![0]!.containerType = {
|
||
code: '40GP',
|
||
sizeFt: 40,
|
||
} as never;
|
||
const result = planWagonsWithStock({
|
||
bookings: [fortyFooter],
|
||
allowed: {
|
||
byContainerTypeId: new Map([['ct-1', [nw6]]]),
|
||
byCargoTypeId: new Map(),
|
||
},
|
||
stock: {
|
||
mode: 'YARD',
|
||
remainingByTypeId: new Map([[nw6.id, 1]]),
|
||
codesByTypeId: new Map([[nw6.id, nw6.code]]),
|
||
},
|
||
});
|
||
|
||
expect(result.deferred).toHaveLength(1);
|
||
expect(result.deferred[0]?.shortage).toEqual({
|
||
wagonTypeCodes: 'NW6',
|
||
wagonsNeeded: 2,
|
||
wagonsAvailable: 1,
|
||
wagonsShort: 1,
|
||
});
|
||
// The rolled-back wagon is plannable again for later bookings.
|
||
expect(result.plan).toHaveLength(0);
|
||
});
|
||
|
||
it('leaves shortage unset for configuration problems', () => {
|
||
const bulkBooking = {
|
||
id: 'BKG-3',
|
||
reference: 'BKG-3',
|
||
freightType: 'BULK',
|
||
cargoTotalWeightVgm: 40,
|
||
cargoTypeId: 'cargo-1',
|
||
cargoType: { id: 'cargo-1', cargoTypeName: 'Fertilizer' },
|
||
bookingContainers: [],
|
||
} as unknown as Booking;
|
||
|
||
const result = planWagonsWithStock({
|
||
bookings: [bulkBooking],
|
||
allowed: {
|
||
byContainerTypeId: new Map(),
|
||
byCargoTypeId: new Map(), // no wagon types configured → config issue
|
||
},
|
||
stock: {
|
||
mode: 'YARD',
|
||
remainingByTypeId: new Map([[cw3.id, 5]]),
|
||
codesByTypeId: new Map([[cw3.id, cw3.code]]),
|
||
},
|
||
});
|
||
|
||
expect(result.configIssues).toHaveLength(1);
|
||
expect(result.deferred[0]?.shortage).toBeNull();
|
||
});
|
||
});
|
||
|
||
describe('applyWagonOrderReversal', () => {
|
||
const slot = (
|
||
seq: number,
|
||
wagonTypeId: string,
|
||
bookingId: string,
|
||
): WagonPlanSlot =>
|
||
({
|
||
sequenceNo: seq,
|
||
wagonTypeId,
|
||
capacityTons: 70,
|
||
lengthMeters: 14,
|
||
assignedWeightTons: 25,
|
||
allocations: [{ bookingId }],
|
||
}) as unknown as WagonPlanSlot;
|
||
|
||
const plan: WagonPlanSlot[] = [
|
||
slot(1, 'wt-a', 'BKG-A'),
|
||
slot(2, 'wt-b', 'BKG-B'),
|
||
slot(3, 'wt-c', 'BKG-C'),
|
||
];
|
||
|
||
it('returns the plan unchanged when the flag is false/absent', () => {
|
||
expect(applyWagonOrderReversal(plan, false)).toBe(plan);
|
||
expect(applyWagonOrderReversal(plan, undefined)).toBe(plan);
|
||
expect(applyWagonOrderReversal(plan, null)).toBe(plan);
|
||
});
|
||
|
||
it('flips the position numbers when the flag is true', () => {
|
||
const reversed = applyWagonOrderReversal(plan, true);
|
||
// Physically-last wagon (wt-c) is now position 1.
|
||
expect(reversed.map((s) => s.sequenceNo)).toEqual([3, 2, 1]);
|
||
});
|
||
|
||
it('keeps each booking with its own wagon — only the position changes', () => {
|
||
const reversed = applyWagonOrderReversal(plan, true);
|
||
// The booking that was in the last wagon now sits at sequenceNo 1.
|
||
const atPosition1 = reversed.find((s) => s.sequenceNo === 1);
|
||
expect(
|
||
(atPosition1?.allocations as { bookingId: string }[])[0].bookingId,
|
||
).toBe('BKG-C');
|
||
const atPosition3 = reversed.find((s) => s.sequenceNo === 3);
|
||
expect(
|
||
(atPosition3?.allocations as { bookingId: string }[])[0].bookingId,
|
||
).toBe('BKG-A');
|
||
});
|
||
|
||
// The regression that emptied every reversed train's container items: the
|
||
// placement generators pair unit k (booking order) with slot k of this array,
|
||
// and persistAllocationsAndLoads matches that sequenceNo against the
|
||
// allocation's booking. Array order must stay packing order.
|
||
it('keeps array order aligned with booking order so placements still match', () => {
|
||
const reversed = applyWagonOrderReversal(plan, true);
|
||
expect(
|
||
reversed.map((s) => (s.allocations as { bookingId: string }[])[0].bookingId),
|
||
).toEqual(['BKG-A', 'BKG-B', 'BKG-C']);
|
||
});
|
||
|
||
it('does not mutate the input plan', () => {
|
||
applyWagonOrderReversal(plan, true);
|
||
expect(plan.map((s) => s.sequenceNo)).toEqual([1, 2, 3]);
|
||
expect(plan.map((s) => s.wagonTypeId)).toEqual(['wt-a', 'wt-b', 'wt-c']);
|
||
});
|
||
});
|
||
|
||
describe('planWagonsWithStock — leg-aware stock (intercity ride-along)', () => {
|
||
const allowed = {
|
||
byContainerTypeId: new Map([['ct-1', [nw6]]]),
|
||
byCargoTypeId: new Map(),
|
||
};
|
||
// Corridor Gelan(0) → Adama(1) → Doraleh(2): edges 0 and 1.
|
||
const legs = (entries: Array<[string, { from: number; to: number }]>) =>
|
||
new Map(entries);
|
||
|
||
it('lets an intercity booking ride the empty leg of a train that is full on the other leg', () => {
|
||
// 1 wagon in stock. Export rides edge 1 only; intercity rides edge 0 only:
|
||
// the intercity 20ft alights where the export 20ft boards, so both share
|
||
// the single physical wagon (cross-leg TEU sharing).
|
||
const result = planWagonsWithStock({
|
||
bookings: [
|
||
containerBooking('EXPORT-1', 1, 1),
|
||
containerBooking('INTERCITY-1', 1, 1),
|
||
],
|
||
allowed,
|
||
stock: {
|
||
mode: 'TRAIN',
|
||
remainingByTypeId: new Map([[nw6.id, 1]]),
|
||
codesByTypeId: new Map([[nw6.id, nw6.code]]),
|
||
},
|
||
legs: legs([
|
||
['EXPORT-1', { from: 1, to: 2 }],
|
||
['INTERCITY-1', { from: 0, to: 1 }],
|
||
]),
|
||
edgeCount: 2,
|
||
});
|
||
|
||
expect(result.deferred).toHaveLength(0);
|
||
expect(result.fitting.map((b) => b.id).sort()).toEqual([
|
||
'EXPORT-1',
|
||
'INTERCITY-1',
|
||
]);
|
||
expect(result.plan).toHaveLength(1);
|
||
});
|
||
|
||
it('still defers when the wagon has no per-edge TEU room and stock is exhausted', () => {
|
||
// Export is a 40ft (2 TEU) riding the whole corridor — no edge has room
|
||
// for the intercity 20ft, and there is no second wagon to open.
|
||
const fortyFooter = containerBooking('EXPORT-1', 1, 1);
|
||
fortyFooter.bookingContainers![0]!.containerType = {
|
||
code: '40GP',
|
||
sizeFt: 40,
|
||
} as never;
|
||
const result = planWagonsWithStock({
|
||
bookings: [fortyFooter, containerBooking('INTERCITY-1', 1, 1)],
|
||
allowed,
|
||
stock: {
|
||
mode: 'TRAIN',
|
||
remainingByTypeId: new Map([[nw6.id, 1]]),
|
||
codesByTypeId: new Map([[nw6.id, nw6.code]]),
|
||
},
|
||
legs: legs([
|
||
['EXPORT-1', { from: 0, to: 2 }],
|
||
['INTERCITY-1', { from: 0, to: 1 }],
|
||
]),
|
||
edgeCount: 2,
|
||
});
|
||
|
||
expect(result.fitting.map((b) => b.id)).toEqual(['EXPORT-1']);
|
||
expect(result.deferred).toHaveLength(1);
|
||
expect(result.deferred[0]!.reference).toBe('INTERCITY-1');
|
||
expect(result.deferred[0]!.reason).toContain('Train has no free NW6 wagon left');
|
||
});
|
||
|
||
it('packs disjoint-leg 20fts onto one wagon instead of appending a second', () => {
|
||
// Two 20ft units, two wagons in stock — cross-leg TEU sharing still fills
|
||
// the open wagon (span grows to the union) rather than opening wagon #2.
|
||
const result = planWagonsWithStock({
|
||
bookings: [
|
||
containerBooking('EXPORT-1', 1, 1),
|
||
containerBooking('INTERCITY-1', 1, 1),
|
||
],
|
||
allowed,
|
||
stock: {
|
||
mode: 'TRAIN',
|
||
remainingByTypeId: new Map([[nw6.id, 2]]),
|
||
codesByTypeId: new Map([[nw6.id, nw6.code]]),
|
||
},
|
||
legs: legs([
|
||
['EXPORT-1', { from: 1, to: 2 }],
|
||
['INTERCITY-1', { from: 0, to: 1 }],
|
||
]),
|
||
edgeCount: 2,
|
||
});
|
||
|
||
expect(result.deferred).toHaveLength(0);
|
||
expect(result.plan).toHaveLength(1);
|
||
const bookingsInSlot = [
|
||
...new Set(result.plan[0]!.allocations.map((a) => a.bookingId)),
|
||
].sort();
|
||
expect(bookingsInSlot).toEqual(['EXPORT-1', 'INTERCITY-1']);
|
||
});
|
||
|
||
it('behaves exactly like the whole-route planner when no legs are given', () => {
|
||
const result = planWagonsWithStock({
|
||
bookings: [
|
||
containerBooking('EXPORT-1', 1, 1),
|
||
containerBooking('INTERCITY-1', 1, 1),
|
||
],
|
||
allowed,
|
||
stock: {
|
||
mode: 'TRAIN',
|
||
remainingByTypeId: new Map([[nw6.id, 1]]),
|
||
codesByTypeId: new Map([[nw6.id, nw6.code]]),
|
||
},
|
||
});
|
||
|
||
// One wagon, two 20ft bookings: they TEU-share the single slot (legacy).
|
||
expect(result.deferred).toHaveLength(0);
|
||
expect(result.plan).toHaveLength(1);
|
||
});
|
||
});
|
||
|
||
describe('planWagonsWithStock — break-bulk (PER_ITEM) item-aware packing', () => {
|
||
const pw2: WagonType = {
|
||
id: 'wt-pw2',
|
||
code: 'PW2',
|
||
capacityTons: 70,
|
||
lengthMeters: 17,
|
||
supportedLoadTypes: ['BULK'],
|
||
isActive: true,
|
||
supportsContainer: false,
|
||
} as WagonType;
|
||
const nw5: WagonType = {
|
||
id: 'wt-nw5',
|
||
code: 'NW5',
|
||
capacityTons: 70,
|
||
lengthMeters: 14,
|
||
supportedLoadTypes: ['BULK'],
|
||
isActive: true,
|
||
supportsContainer: false,
|
||
} as WagonType;
|
||
|
||
// 20 machinery items, 100T total (5T each). NW5 fits 4/wagon, PW2 fits 3.
|
||
const machineryBooking = (): Booking =>
|
||
({
|
||
id: 'BULK-ITEMS',
|
||
reference: 'BULK-ITEMS',
|
||
freightType: 'BULK',
|
||
cargoTypeId: 'ct-machinery',
|
||
cargoTotalWeightVgm: 20,
|
||
bulkTotalWeightTons: 100,
|
||
cargoType: {
|
||
id: 'ct-machinery',
|
||
cargoTypeName: 'Machinery',
|
||
itemsPerWagonMap: { 'wt-nw5': 4, 'wt-pw2': 3 },
|
||
wagonTypes: [pw2, nw5],
|
||
},
|
||
}) as unknown as Booking;
|
||
|
||
const allowed = {
|
||
byContainerTypeId: new Map<string, WagonType[]>(),
|
||
byCargoTypeId: new Map([['ct-machinery', [pw2, nw5]]]),
|
||
};
|
||
|
||
it('packs whole items per wagon by the items-fit map, not raw tonnage', () => {
|
||
const result = planWagonsWithStock({
|
||
bookings: [machineryBooking()],
|
||
allowed,
|
||
stock: {
|
||
mode: 'YARD',
|
||
remainingByTypeId: new Map([
|
||
[pw2.id, 50],
|
||
[nw5.id, 50],
|
||
]),
|
||
codesByTypeId: new Map([
|
||
[pw2.id, pw2.code],
|
||
[nw5.id, nw5.code],
|
||
]),
|
||
},
|
||
});
|
||
|
||
expect(result.deferred).toHaveLength(0);
|
||
// Best fit: NW5 at 4 items/wagon → ceil(20/4) = 5 wagons, 20T each.
|
||
expect(result.plan).toHaveLength(5);
|
||
expect(result.plan.every((s) => s.wagonTypeCode === 'NW5')).toBe(true);
|
||
expect(result.plan.map((s) => s.assignedWeightTons)).toEqual([20, 20, 20, 20, 20]);
|
||
});
|
||
|
||
it('weight cap binds before items-fit when items are heavy', () => {
|
||
// 14 items of 10T on 70T wagons with a 100-item floor fit → 7 items/wagon.
|
||
const heavy = {
|
||
...machineryBooking(),
|
||
cargoTotalWeightVgm: 14,
|
||
bulkTotalWeightTons: 140,
|
||
cargoType: {
|
||
id: 'ct-machinery',
|
||
cargoTypeName: 'Machinery',
|
||
itemsPerWagonMap: { 'wt-nw5': 100, 'wt-pw2': 100 },
|
||
wagonTypes: [pw2, nw5],
|
||
},
|
||
} as unknown as Booking;
|
||
const result = planWagonsWithStock({
|
||
bookings: [heavy],
|
||
allowed,
|
||
stock: {
|
||
mode: 'YARD',
|
||
remainingByTypeId: new Map([
|
||
[pw2.id, 50],
|
||
[nw5.id, 50],
|
||
]),
|
||
codesByTypeId: new Map([
|
||
[pw2.id, pw2.code],
|
||
[nw5.id, nw5.code],
|
||
]),
|
||
},
|
||
});
|
||
|
||
expect(result.deferred).toHaveLength(0);
|
||
expect(result.plan).toHaveLength(2);
|
||
expect(result.plan.map((s) => s.assignedWeightTons)).toEqual([70, 70]);
|
||
});
|
||
|
||
it('PER_TON bulk (no bulkTotalWeightTons) still packs by weight', () => {
|
||
const loose = {
|
||
...machineryBooking(),
|
||
cargoTotalWeightVgm: 100,
|
||
bulkTotalWeightTons: null,
|
||
} as unknown as Booking;
|
||
const result = planWagonsWithStock({
|
||
bookings: [loose],
|
||
allowed,
|
||
stock: {
|
||
mode: 'YARD',
|
||
remainingByTypeId: new Map([
|
||
[pw2.id, 50],
|
||
[nw5.id, 50],
|
||
]),
|
||
codesByTypeId: new Map([
|
||
[pw2.id, pw2.code],
|
||
[nw5.id, nw5.code],
|
||
]),
|
||
},
|
||
});
|
||
|
||
expect(result.deferred).toHaveLength(0);
|
||
expect(result.plan).toHaveLength(2);
|
||
expect(result.plan.map((s) => s.assignedWeightTons)).toEqual([70, 30]);
|
||
});
|
||
});
|