mirror of
https://github.com/Tria-plc/edr-platform.git
synced 2026-08-26 18:42:49 +00:00
add Group 9 delivery scenarios for self-haul and last-mile paths
- Implemented G9·S38 tests for customer self-haul truck assignments, ensuring compliance with container limits and truck assignments. - Added G9·S39 tests for last-mile delivery, self-haul, and yard pickup, verifying independent paths for multiple bookings on the same train. - Created seed data for Group 1 and Group 2 scenarios, ensuring proper setup for weight and capacity tests. - Updated booking interface to deprecate in favor of for better clarity in allocations.
This commit is contained in:
Marshal
568
e2e/freight/cypress/e2e/flows/g1-utils.ts
Normal file
568
e2e/freight/cypress/e2e/flows/g1-utils.ts
Normal file
@@ -0,0 +1,568 @@
|
||||
/**
|
||||
* Shared helpers for the GROUP 1 scenario specs (g1_s1 … g1_s8).
|
||||
*
|
||||
* These specs are the "visual" variant of the corridor suite: the fleet
|
||||
* configuration phase (wagons → locomotives → train consist → schedule) and
|
||||
* every capacity verdict are driven and asserted through the BACKOFFICE UI,
|
||||
* while the bulk of the cargo (50+ wagons ≈ 100+ ISO container inputs per
|
||||
* scenario) is still created through the API. See `bookOneVisually` below for
|
||||
* where the line is drawn and why.
|
||||
*
|
||||
* Everything here builds on ./import-utils — the corridor route, contract
|
||||
* seeding, window choreography and polling are unchanged. This module adds
|
||||
* only what Group 1 needs on top:
|
||||
*
|
||||
* - a 53-WAGON BUILT TRAIN (seed-g1-train.sql). Group 1's arithmetic is
|
||||
* written for 53 slots; a loco-pair schedule cannot hold that number
|
||||
* because syncScheduleMaxWagons recomputes max_wagons from locomotive
|
||||
* length (floor(760 / 13.966) = 54 on this corridor). A built train's
|
||||
* physical consist wins outright — booking-batch.service.ts:4152:
|
||||
* const maxWagons = physicalWagons ?? capacityLimits(loco).base.wagons
|
||||
* so the consist staff marshal IS the capacity, and it survives the tick.
|
||||
*
|
||||
* - the FULL / NOT FULL verdict helpers, which every scenario ends on.
|
||||
*
|
||||
* No module-level mutable state: Cypress re-evaluates the spec bundle on every
|
||||
* cross-origin visit, so helpers resolve rows by stamped-reference suffix and
|
||||
* newest-row, never by a captured id. (Same rule as import-utils.)
|
||||
*/
|
||||
|
||||
import {
|
||||
apiPost,
|
||||
closeBookingWindow,
|
||||
db,
|
||||
dbSchedule,
|
||||
forceWindowOpen,
|
||||
opsStaff,
|
||||
ORIGIN,
|
||||
pollDb,
|
||||
withBooking,
|
||||
withSchedule,
|
||||
type ScheduleRow,
|
||||
} from "./import-utils";
|
||||
|
||||
/** The Group 1 built train's consist size — see seed-g1-train.sql. */
|
||||
export const G1_WAGONS = 53;
|
||||
export const G1_TRAIN = "TRN-G1-1";
|
||||
/** Second identical train, for the multi-schedule scenarios. */
|
||||
export const G1_TRAIN_2 = "TRN-G1-2";
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// wagon arithmetic — the number every scenario is written in
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Escape a DB-sourced string for use inside a RegExp. Yard and train labels go
|
||||
* straight into `cy.contains(new RegExp(...))` selectors, and a label carrying
|
||||
* a metacharacter (a "." or "(" in a yard name) would otherwise silently match
|
||||
* the wrong option — or nothing at all.
|
||||
*/
|
||||
export function escapeRegExp(value: string): string {
|
||||
return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
|
||||
}
|
||||
|
||||
/**
|
||||
* A Date as the unzoned "YYYY-MM-DDTHH:mm" wall-clock string that an
|
||||
* `<input type="datetime-local">` accepts (the create-schedule form's Departure
|
||||
* date field). The corridor departures are pinned to 12:00 EAT = 09:00 UTC, so
|
||||
* the wall-clock the operator types is the EAT one — the browser running the
|
||||
* test is UTC in CI and EAT on a local machine, and typing a UTC-rendered
|
||||
* string on an EAT machine would file the departure three hours early and land
|
||||
* it on the wrong booking day.
|
||||
*/
|
||||
export function localDateTime(d: Date): string {
|
||||
const eat = new Date(d.getTime() + 3 * 3_600_000);
|
||||
return eat.toISOString().slice(0, 16);
|
||||
}
|
||||
|
||||
/**
|
||||
* Wagons a container booking needs: 20ft containers pair up two-per-wagon,
|
||||
* 40ft take a whole wagon each. An ODD 20ft count still costs a whole wagon
|
||||
* (and the portal form blocks submitting one — `hasOdd20ft`), so callers
|
||||
* should keep 20ft quantities even.
|
||||
*/
|
||||
export function wagonsFor(twenty: number, forty: number): number {
|
||||
return Math.ceil(twenty / 2) + forty;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// the built-train schedule
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Create the Group 1 schedule on the corridor from the BUILT 53-wagon train.
|
||||
*
|
||||
* Deliberately NOT `createImportSchedule({ locoPair })`: that path derives
|
||||
* capacity from locomotive length and would give 54 slots. Passing the train
|
||||
* makes the coupled consist the cap (see module header).
|
||||
*/
|
||||
export function createG1Schedule(opts: {
|
||||
departure: Date;
|
||||
trainCode?: string;
|
||||
routeId: string;
|
||||
}) {
|
||||
const trainCode = opts.trainCode ?? G1_TRAIN;
|
||||
dbSchedule(opts.departure).then(({ rows }) => {
|
||||
if (rows.length > 0) return;
|
||||
db<{ id: string }>(`SELECT id FROM freight.trains WHERE code = $1`, [trainCode]).then(
|
||||
({ rows: trains }) => {
|
||||
expect(trains, `built train ${trainCode}`).to.have.length(1);
|
||||
apiPost(opsStaff, "/api/train-scheduling/container/schedules", {
|
||||
routeId: opts.routeId,
|
||||
scheduleDate: opts.departure.toISOString(),
|
||||
trainId: trains[0].id,
|
||||
})
|
||||
.its("status")
|
||||
.should("be.oneOf", [200, 201]);
|
||||
},
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* The visual configuration phase, shared by every Group 1 scenario: operations
|
||||
* schedules the built train on the corridor through the REAL create form
|
||||
* (Route → Departure date → Train), then the window is opened.
|
||||
*
|
||||
* The form is built-train only — there is no locomotive-pair option and no
|
||||
* max-wagons field in it (the pair path lives in AllocateBookingWizard), which
|
||||
* is exactly what this suite wants: the consist chosen here IS the capacity.
|
||||
*
|
||||
* Leaves the schedule OPEN with `closesInMinutes` of window left.
|
||||
*/
|
||||
export function configureAndOpenSchedule(opts: {
|
||||
departure: Date;
|
||||
trainCode?: string;
|
||||
originCode?: string;
|
||||
closesInMinutes?: number;
|
||||
wagons?: number;
|
||||
}) {
|
||||
const trainCode = opts.trainCode ?? G1_TRAIN;
|
||||
const originCode = opts.originCode ?? ORIGIN;
|
||||
|
||||
cy.loginBackoffice(opsStaff);
|
||||
cy.visit("/dashboard/operations/train-scheduling-v2");
|
||||
cy.contains("button", "New schedule", { timeout: 30000 }).click();
|
||||
cy.contains("Create train schedule", { timeout: 20000 }).should("be.visible");
|
||||
|
||||
// Route options are composed by formatRouteLabel, which renders yard LABELS
|
||||
// ("Djibouti Port"), never codes — so resolve the label for this corridor.
|
||||
db<{ label: string }>(`SELECT label FROM freight.yards WHERE code = $1`, [
|
||||
originCode,
|
||||
]).then(({ rows }) => {
|
||||
expect(rows, `origin yard ${originCode}`).to.have.length(1);
|
||||
cy.mantineSelect("Route", new RegExp(escapeRegExp(rows[0].label)));
|
||||
});
|
||||
// datetime-local takes an unzoned "YYYY-MM-DDTHH:mm" wall-clock string.
|
||||
cy.get('input[type="datetime-local"]').type(localDateTime(opts.departure), {
|
||||
force: true,
|
||||
});
|
||||
// Option text is composed: "TRN-G1-1 — E2E Group-1 … · 53 wagons".
|
||||
cy.mantineSelect("Train", new RegExp(escapeRegExp(trainCode)));
|
||||
cy.get(".mantine-Modal-content").contains("button", "Create").click();
|
||||
cy.get(".mantine-Modal-content", { timeout: 30000 }).should("not.exist");
|
||||
|
||||
expectCapacity(opts.departure, opts.wagons ?? G1_WAGONS);
|
||||
withSchedule(opts.departure, (s) => forceWindowOpen(s.id, opts.closesInMinutes ?? 45));
|
||||
}
|
||||
|
||||
/**
|
||||
* Close the window and run the batch from the board's own button — the one
|
||||
* manual phase action the app exposes (closing itself is time-driven; there is
|
||||
* no "close window" control anywhere in the UI).
|
||||
*
|
||||
* Asserts the phase actually advanced: a button that silently no-ops would
|
||||
* otherwise leave every downstream assertion to time out far from the cause.
|
||||
*/
|
||||
export function closeWindowAndRunBatch(departure: Date) {
|
||||
withSchedule(departure, (s) => closeBookingWindow(s.id));
|
||||
|
||||
cy.loginBackoffice(opsStaff);
|
||||
withSchedule(departure, (s) => cy.visit(`/dashboard/operations/batch-board/${s.id}`));
|
||||
cy.contains("Doc review", { timeout: 30000 }).should("exist");
|
||||
cy.contains("button", "Doc review complete — run batch", { timeout: 20000 }).click();
|
||||
|
||||
withSchedule(departure, (s) =>
|
||||
pollDb<ScheduleRow>(
|
||||
"batch ran — window phase advanced",
|
||||
`SELECT window_phase FROM freight.train_schedules WHERE id = $1`,
|
||||
[s.id],
|
||||
// DONE when the batch reserved nobody — itself a scenario outcome.
|
||||
(row) => !!row && ["PAYMENT", "DONE"].includes(row.window_phase as string),
|
||||
20,
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Read the Priority Tracking board: the lane counts and the capacity divider.
|
||||
* Pass only what the scenario cares about.
|
||||
*
|
||||
* The divider is ONE text node — `Capacity line · 53/53 wagons · FULL` — so
|
||||
* the FULL suffix cannot be asserted separately from the ratio.
|
||||
*/
|
||||
export function expectBoard(
|
||||
departure: Date,
|
||||
opts: {
|
||||
inBatch?: number;
|
||||
waiting?: number;
|
||||
expired?: number;
|
||||
capacity?: { used: number; max?: number; full?: boolean };
|
||||
},
|
||||
) {
|
||||
cy.loginBackoffice(opsStaff);
|
||||
withSchedule(departure, (s) => cy.visit(`/dashboard/operations/batch-board/${s.id}`));
|
||||
cy.contains(/Priority Tracking/, { timeout: 30000 }).click();
|
||||
cy.contains("Priority ranking", { timeout: 20000 }).should("be.visible");
|
||||
|
||||
if (opts.inBatch !== undefined) {
|
||||
cy.contains(new RegExp(`In the batch\\s*\\(${opts.inBatch}\\)`), {
|
||||
timeout: 20000,
|
||||
}).should("exist");
|
||||
}
|
||||
if (opts.waiting !== undefined) {
|
||||
if (opts.waiting === 0) cy.contains(/Waiting list/).should("not.exist");
|
||||
else cy.contains(new RegExp(`Waiting list\\s*\\(${opts.waiting}\\)`)).should("exist");
|
||||
}
|
||||
if (opts.expired !== undefined) {
|
||||
if (opts.expired === 0) cy.contains(/Expired\s*\(/).should("not.exist");
|
||||
else cy.contains(new RegExp(`Expired\\s*\\(${opts.expired}\\)`)).should("exist");
|
||||
}
|
||||
if (opts.capacity) {
|
||||
const max = opts.capacity.max ?? G1_WAGONS;
|
||||
const suffix = opts.capacity.full ? " · FULL" : "";
|
||||
cy.contains(`Capacity line · ${opts.capacity.used}/${max} wagons${suffix}`).should(
|
||||
"exist",
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Assert the schedule's capacity is the built consist, not the loco-derived
|
||||
* 54. Worth asserting explicitly in every scenario's config phase: if a future
|
||||
* change lets the length recompute win again, EVERY Group 1 expectation shifts
|
||||
* by one slot and the exact-fit cases (S1, S2) would fail somewhere far from
|
||||
* the cause.
|
||||
*/
|
||||
export function expectCapacity(departure: Date, wagons = G1_WAGONS) {
|
||||
dbSchedule(departure).then(({ rows }) => {
|
||||
expect(rows, "G1 schedule").to.have.length(1);
|
||||
expect(rows[0].max_wagons, `consist capacity = ${wagons}`).to.eq(wagons);
|
||||
});
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// the verdict — every scenario ends naming its binding axis
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/** Distinct wagon slots actually allocated to bookings on a schedule. */
|
||||
export function allocatedWagons(scheduleId: string) {
|
||||
return db<{ n: string }>(
|
||||
`SELECT count(DISTINCT wba.train_set_wagon_id) AS n
|
||||
FROM freight.wagon_booking_allocations wba
|
||||
JOIN freight.train_schedule_bookings tsb
|
||||
ON tsb.booking_id = wba.booking_id AND tsb.train_schedule_id = $1
|
||||
WHERE wba.deleted_at IS NULL AND tsb.deleted_at IS NULL`,
|
||||
[scheduleId],
|
||||
).then(({ rows }) => Number(rows[0].n));
|
||||
}
|
||||
|
||||
/**
|
||||
* The scenario's closing verdict: how many of the train's slots ended up
|
||||
* filled, and whether the engine agrees it is FULL.
|
||||
*
|
||||
* `booking_window_status` is the engine's own word (FULL / OPEN / CLOSED) —
|
||||
* asserting the slot count alone would pass on a train that is physically full
|
||||
* but which the window state machine never marked, which is exactly the bug
|
||||
* class these scenarios exist to catch.
|
||||
*/
|
||||
export function expectVerdict(
|
||||
departure: Date,
|
||||
expected: { wagons: number; full: boolean; capacity?: number },
|
||||
) {
|
||||
const capacity = expected.capacity ?? G1_WAGONS;
|
||||
dbSchedule(departure).then(({ rows }) => {
|
||||
expect(rows, "G1 schedule").to.have.length(1);
|
||||
const schedule = rows[0];
|
||||
allocatedWagons(schedule.id).then((n) => {
|
||||
expect(n, `${expected.wagons}/${capacity} wagons allocated`).to.eq(expected.wagons);
|
||||
});
|
||||
if (expected.full) {
|
||||
pollDb<ScheduleRow>(
|
||||
`window FULL (${expected.wagons}/${capacity})`,
|
||||
`SELECT booking_window_status FROM freight.train_schedules WHERE id = $1`,
|
||||
[schedule.id],
|
||||
(row) => row?.booking_window_status === "FULL",
|
||||
20,
|
||||
);
|
||||
} else {
|
||||
db<ScheduleRow>(
|
||||
`SELECT booking_window_status FROM freight.train_schedules WHERE id = $1`,
|
||||
[schedule.id],
|
||||
).then(({ rows: after }) => {
|
||||
expect(
|
||||
after[0].booking_window_status,
|
||||
`not FULL (${expected.wagons}/${capacity})`,
|
||||
).to.not.eq("FULL");
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// booking through the real portal form
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Book containers the way a customer actually does: the portal's New Shipment
|
||||
* form, end to end. Reserved for the SMALL booking in each scenario — one
|
||||
* container is one ISO input, so a 30-wagon booking would mean 30-60 of them.
|
||||
*
|
||||
* The three traps this navigates (all learned from export_one_time.cy.ts and
|
||||
* the form source):
|
||||
* 1. size editors render in CONTRACT-SCOPE order, not 20ft-then-40ft, so
|
||||
* each is addressed by its "20ft containers" heading;
|
||||
* 2. the shipment-day calendar does not render until the cargo quantities
|
||||
* are valid — "available days depend on the wagons your cargo needs";
|
||||
* 3. a blank cargo description aborts the submit SILENTLY (no modal, no
|
||||
* toast, no request) — cy.fillCargoDescription covers it.
|
||||
*
|
||||
* Leaves the browser on /bookings/:id, the page the form redirects to.
|
||||
*/
|
||||
export function bookContainersVisually(opts: {
|
||||
contractId: string;
|
||||
twenty?: number;
|
||||
forty?: number;
|
||||
/** Day to pick in the inline calendar — must be a bookable (enabled) day. */
|
||||
shipmentDay: Date;
|
||||
/** Distinct ISO prefixes keep container numbers unique across scenarios. */
|
||||
isoPrefix?: string;
|
||||
vgmTons?: number;
|
||||
}) {
|
||||
const twenty = opts.twenty ?? 0;
|
||||
const forty = opts.forty ?? 0;
|
||||
const total = twenty + forty;
|
||||
expect(total, "at least one container").to.be.greaterThan(0);
|
||||
// The form blocks an odd 20ft count (a lone 20ft cannot be paired onto a
|
||||
// wagon) — "Review price & book" would stay disabled and the spec would
|
||||
// fail on a timeout rather than on this, the real reason.
|
||||
expect(twenty % 2, "20ft quantity must be even").to.eq(0);
|
||||
|
||||
cy.visitPortal(`/contracts/${opts.contractId}/bookings/new`);
|
||||
cy.contains("New Shipment Booking", { timeout: 30000 }).should("be.visible");
|
||||
|
||||
if (twenty) fillSizeQuantity("20ft", String(twenty));
|
||||
if (forty) fillSizeQuantity("40ft", String(forty));
|
||||
|
||||
// One ISO row per container, then the VGM on each.
|
||||
const prefix = opts.isoPrefix ?? "MSCU";
|
||||
cy.get('input[placeholder*="MSCU"]', { timeout: 20000 }).should("have.length", total);
|
||||
for (let i = 0; i < total; i += 1) {
|
||||
cy.get('input[placeholder*="MSCU"]')
|
||||
.eq(i)
|
||||
.clear({ force: true })
|
||||
.type(`${prefix}${String(1_000_000 + i).slice(0, 7)}`, { force: true });
|
||||
}
|
||||
cy.get('input[placeholder*="24.5"]').each(($input) => {
|
||||
cy.wrap($input)
|
||||
.clear({ force: true })
|
||||
.type(String(opts.vgmTons ?? 10), { force: true });
|
||||
});
|
||||
|
||||
pickShipmentDay(opts.shipmentDay);
|
||||
cy.fillCargoDescription();
|
||||
|
||||
cy.contains("button", "Review price & book").should("not.be.disabled").click();
|
||||
cy.contains("Confirm shipment price", { timeout: 30000 }).should("be.visible");
|
||||
cy.contains("button", "Confirm & book").click();
|
||||
cy.location("pathname", { timeout: 30000 }).should("match", /^\/bookings\/.+/);
|
||||
}
|
||||
|
||||
/** One container-size line's quantity, addressed by its heading (see above). */
|
||||
function fillSizeQuantity(size: "20ft" | "40ft", value: string) {
|
||||
cy.contains(`${size} containers`, { timeout: 20000 })
|
||||
.closest("div.rounded-xl")
|
||||
.find('input[type="number"]')
|
||||
.first()
|
||||
.clear({ force: true })
|
||||
.type(value, { force: true });
|
||||
}
|
||||
|
||||
/** Pick a day on the Schedule card's inline, cargo-aware calendar. */
|
||||
function pickShipmentDay(day: Date) {
|
||||
cy.contains(/available day/, { timeout: 30000 }).should("exist");
|
||||
// Day cells are plain buttons in a grid; only bookable days are enabled
|
||||
// (out-of-month duplicates and unscheduled days stay disabled).
|
||||
const eatDay = new Date(day.getTime() + 3 * 3_600_000).getUTCDate();
|
||||
cy.get("button:not(:disabled)", { timeout: 20000 })
|
||||
.contains(new RegExp(`^${eatDay}$`))
|
||||
.click({ force: true });
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// visual assertions on the backoffice schedule board
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Open the schedule's detail page as operations staff. Every scenario does
|
||||
* this at least twice — once after configuring the train (to SEE the empty
|
||||
* 53-slot consist) and once at the end (to SEE the verdict).
|
||||
*/
|
||||
export function visitSchedule(departure: Date) {
|
||||
cy.loginBackoffice(opsStaff);
|
||||
dbSchedule(departure).then(({ rows }) => {
|
||||
expect(rows, "G1 schedule").to.have.length(1);
|
||||
cy.visit(`/dashboard/operations/train-scheduling-v2/${rows[0].id}`);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Every container on the train mapped to a wagon slot, with a real container
|
||||
* number on it.
|
||||
*
|
||||
* Wagon-slot counts alone cannot catch a half-done allocation: a booking whose
|
||||
* wagons were reserved but whose units were never placed still reads as a full
|
||||
* train on the board. The units live in `wagon_allocation_container_items`
|
||||
* (one row per container, `position_on_wagon` + `container_number`), hanging
|
||||
* off `wagon_booking_allocations`.
|
||||
*/
|
||||
export function expectContainersPlaced(scheduleId: string, containers: number) {
|
||||
pollDb<{ n: string }>(
|
||||
`${containers} containers mapped to wagon slots`,
|
||||
`SELECT count(*) AS n
|
||||
FROM freight.wagon_allocation_container_items ci
|
||||
JOIN freight.wagon_booking_allocations wba
|
||||
ON wba.id = ci.wagon_booking_allocation_id
|
||||
JOIN freight.train_schedule_bookings tsb
|
||||
ON tsb.booking_id = wba.booking_id AND tsb.train_schedule_id = $1
|
||||
WHERE ci.deleted_at IS NULL AND wba.deleted_at IS NULL
|
||||
AND tsb.deleted_at IS NULL`,
|
||||
[scheduleId],
|
||||
(row) => Number(row?.n ?? 0) === containers,
|
||||
25,
|
||||
);
|
||||
// A placed unit with no number would be an empty slot wearing a container's
|
||||
// name — the marshalling sheet is generated from exactly this column.
|
||||
db<{ n: string }>(
|
||||
`SELECT count(*) AS n
|
||||
FROM freight.wagon_allocation_container_items ci
|
||||
JOIN freight.wagon_booking_allocations wba
|
||||
ON wba.id = ci.wagon_booking_allocation_id
|
||||
JOIN freight.train_schedule_bookings tsb
|
||||
ON tsb.booking_id = wba.booking_id AND tsb.train_schedule_id = $1
|
||||
WHERE ci.deleted_at IS NULL AND wba.deleted_at IS NULL
|
||||
AND tsb.deleted_at IS NULL
|
||||
AND (ci.container_number IS NULL OR ci.container_number = '')`,
|
||||
[scheduleId],
|
||||
).then(({ rows }) =>
|
||||
expect(Number(rows[0].n), "no slot left without a container number").to.eq(0),
|
||||
);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// split offers — S4, S6, S7, S8
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Poll until the batch has raised a partial (split) offer on a booking.
|
||||
* The engine offers rather than reserves when a booking cannot fit whole but
|
||||
* some room remains — sizePartialOfferWagons budgets that room against the
|
||||
* BASE caps only, never the locomotive's overage tolerance (see S11).
|
||||
*/
|
||||
export function expectSplitOffer(suffix: string) {
|
||||
withBooking(suffix, (b) => {
|
||||
pollDb<{ status: string }>(
|
||||
`${suffix} open partial offer`,
|
||||
`SELECT status FROM freight.booking_batch_offers
|
||||
WHERE booking_id = $1 AND deleted_at IS NULL
|
||||
ORDER BY created_at DESC LIMIT 1`,
|
||||
[b.id],
|
||||
(row) => row?.status === "OFFERED",
|
||||
15,
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
/** Assert NO split offer was raised — the whole-or-nothing cases. */
|
||||
export function expectNoSplitOffer(suffix: string) {
|
||||
withBooking(suffix, (b) => {
|
||||
db<{ n: string }>(
|
||||
`SELECT count(*) AS n FROM freight.booking_batch_offers
|
||||
WHERE booking_id = $1 AND deleted_at IS NULL`,
|
||||
[b.id],
|
||||
).then(({ rows }) => expect(Number(rows[0].n), `${suffix} has no split offer`).to.eq(0));
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Let a split offer lapse rather than paying it (S6). The offer expires with
|
||||
* the booking's pay deadline, so pushing the deadline into the past and
|
||||
* letting the 10s tick run is the same thing the wall clock would do.
|
||||
*/
|
||||
export function forceOfferLapse(suffix: string) {
|
||||
withBooking(suffix, (b) =>
|
||||
db(
|
||||
`UPDATE freight.bookings SET payment_deadline = now() - interval '1 second'
|
||||
WHERE id = $1`,
|
||||
[b.id],
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// waiting list — S1, S5, S24
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* A booking that lost the batch sits at FULLY_EXECUTED with no schedule — it
|
||||
* is on the day's waiting list, not rejected. Promotion happens when capacity
|
||||
* frees up (fillFromWaitingList loops up to 10 rounds, so one expiry can
|
||||
* cascade into several promotions — see S5).
|
||||
*/
|
||||
export function expectWaitlisted(suffix: string) {
|
||||
withBooking(suffix, (b) => {
|
||||
expect(b.status, `${suffix} waitlisted`).to.eq("FULLY_EXECUTED");
|
||||
expect(b.train_schedule_id, `${suffix} holds no seat`).to.be.null;
|
||||
});
|
||||
}
|
||||
|
||||
/** Poll until a waitlisted booking has been promoted into a pay window. */
|
||||
export function expectPromoted(suffix: string) {
|
||||
pollDb<{ status: string; payment_deadline: string | null }>(
|
||||
`${suffix} promoted from the waiting list`,
|
||||
`SELECT b.status, b.payment_deadline FROM freight.bookings b
|
||||
JOIN freight.contracts ct ON ct.id = b.contract_id
|
||||
WHERE ct.reference LIKE 'CTR-IMP-%-' || $1 AND b.deleted_at IS NULL
|
||||
ORDER BY b.created_at DESC LIMIT 1`,
|
||||
[suffix],
|
||||
(row) =>
|
||||
!!row &&
|
||||
["SELECTED_FOR_BATCH", "AWAITING_PAYMENT"].includes(row.status) &&
|
||||
row.payment_deadline !== null,
|
||||
30,
|
||||
);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// recoverability — S1's tail
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* An EXPIRED booking is recoverable without re-approval: its contract is still
|
||||
* FULLY_EXECUTED, so the customer can book again onto a later day. Asserting
|
||||
* the CONTRACT state (not just the booking's) is the point — a bug that also
|
||||
* retired the contract would strand the customer.
|
||||
*/
|
||||
export function expectRecoverable(suffix: string) {
|
||||
withBooking(suffix, (b) => {
|
||||
expect(b.status, `${suffix} expired`).to.eq("EXPIRED");
|
||||
db<{ status: string }>(`SELECT status FROM freight.contracts WHERE id = $1`, [
|
||||
b.contract_id,
|
||||
]).then(({ rows }) =>
|
||||
expect(rows[0].status, `${suffix} contract still bookable`).to.be.oneOf([
|
||||
"FULLY_EXECUTED",
|
||||
"CONTRACT_ACTIVE",
|
||||
]),
|
||||
);
|
||||
});
|
||||
}
|
||||
363
e2e/freight/cypress/e2e/flows/g10_validation.cy.ts
Normal file
363
e2e/freight/cypress/e2e/flows/g10_validation.cy.ts
Normal file
@@ -0,0 +1,363 @@
|
||||
/**
|
||||
* GROUP 10 · S40 — line-level validation and the re-priced booking.
|
||||
*
|
||||
* - hazardous quantity above the line quantity (gap — see below)
|
||||
* - reefer quantity on a DRY container type (gap — see below)
|
||||
* - return quantity above the line quantity (enforced)
|
||||
* - a re-priced booking parks with ZERO capacity footprint
|
||||
*
|
||||
* ── TWO SCENARIO CORRECTIONS (see SCENARIO_ENGINE_NOTES.md) ────────────────
|
||||
*
|
||||
* S40 expects `hazardousQuantity: 12` on a `quantity: 10` line to be REJECTED.
|
||||
* It is not. The DTO carries only @IsOptional @IsInt @Min(0) with no @Max
|
||||
* (create-booking.dto.ts:60-76), and the repository CLAMPS instead of throwing
|
||||
* (bookings.repository.ts:217): the booking is created 201 with the value
|
||||
* silently truncated to 10. Reefer behaves identically.
|
||||
*
|
||||
* Worth noting because it is the same layer and the same shape of data:
|
||||
* `returnQuantity` DOES throw, with a precise message
|
||||
* (contract-booking.service.ts:1740). So the pattern exists in the codebase —
|
||||
* hazardous and reefer just do not use it. That asymmetry is asserted below,
|
||||
* because it is the clearest evidence the clamp is an oversight rather than a
|
||||
* deliberate design.
|
||||
*
|
||||
* S40 also expects reefer to be forced to 0 for DRY container types. No such
|
||||
* logic exists: a DRY type with reeferQuantity > 0 is an explicitly supported
|
||||
* state that applies the REEFER surcharge anyway (booking.entity.ts:384,
|
||||
* booking-pricing.service.ts:402).
|
||||
*
|
||||
* Both are written as passing tests of CURRENT behaviour plus skipped tests of
|
||||
* the DESIRED behaviour.
|
||||
*
|
||||
* Sequential steps per scenario — retries off.
|
||||
*/
|
||||
|
||||
import {
|
||||
acceptOperation,
|
||||
apiPost,
|
||||
bookContainers,
|
||||
customer,
|
||||
db,
|
||||
dbContractId,
|
||||
departureAt,
|
||||
eatDayStr,
|
||||
ensureCorridorRoute,
|
||||
markPaid,
|
||||
pollAllocations,
|
||||
pollBookingStatus,
|
||||
resetCorridorDay,
|
||||
seedImportContract,
|
||||
withBooking,
|
||||
} from "./import-utils";
|
||||
import {
|
||||
G1_WAGONS,
|
||||
closeWindowAndRunBatch,
|
||||
configureAndOpenSchedule,
|
||||
expectVerdict,
|
||||
} from "./g1-utils";
|
||||
|
||||
const stamp = String(Date.now());
|
||||
const stampedRef = (suffix: string) => `CTR-IMP-${stamp}-${suffix}`;
|
||||
|
||||
/** Book one container line directly, so per-line handling counts can be set. */
|
||||
function bookLine(opts: {
|
||||
suffix: string;
|
||||
quantity: number;
|
||||
hazardousQuantity?: number;
|
||||
reeferQuantity?: number;
|
||||
scheduledDate?: string;
|
||||
failOnStatusCode?: boolean;
|
||||
}) {
|
||||
return dbContractId(opts.suffix).then((contractId) =>
|
||||
db<{ id: string }>(
|
||||
`SELECT id FROM freight.container_types
|
||||
WHERE size_ft = 20 AND is_active LIMIT 1`,
|
||||
).then(({ rows }) =>
|
||||
apiPost(
|
||||
customer,
|
||||
`/api/contracts/${contractId}/bookings`,
|
||||
{
|
||||
...(opts.scheduledDate ? { scheduledDate: opts.scheduledDate } : {}),
|
||||
containers: [
|
||||
{
|
||||
containerSize: "20ft",
|
||||
containerTypeId: rows[0].id,
|
||||
quantity: opts.quantity,
|
||||
...(opts.hazardousQuantity !== undefined
|
||||
? { hazardousQuantity: opts.hazardousQuantity }
|
||||
: {}),
|
||||
...(opts.reeferQuantity !== undefined
|
||||
? { reeferQuantity: opts.reeferQuantity }
|
||||
: {}),
|
||||
units: Array.from({ length: opts.quantity }, (_, i) => ({
|
||||
containerNumber: `VLDU${String(3_000_000 + i).slice(0, 7)}`,
|
||||
vgmTons: 10,
|
||||
})),
|
||||
},
|
||||
],
|
||||
},
|
||||
opts.failOnStatusCode ?? true,
|
||||
),
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
/** The persisted per-line handling counts for a booking. */
|
||||
function lineCounts(bookingId: string) {
|
||||
return db<{ quantity: number; hazardous_quantity: number; reefer_quantity: number }>(
|
||||
`SELECT quantity, hazardous_quantity, reefer_quantity
|
||||
FROM freight.booking_container
|
||||
WHERE booking_id = $1 AND deleted_at IS NULL
|
||||
ORDER BY created_at LIMIT 1`,
|
||||
[bookingId],
|
||||
).then(({ rows }) => rows[0]);
|
||||
}
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// Line-level handling counts
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G10·S40: line-level handling quantities", { retries: 0 }, () => {
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g1-train.sql");
|
||||
(["VH", "VR", "VOK"] as const).forEach((suffix) =>
|
||||
seedImportContract({ suffix, reference: stampedRef(suffix) }),
|
||||
);
|
||||
});
|
||||
|
||||
it("a hazardous count WITHIN the line quantity is stored as given", () => {
|
||||
bookLine({ suffix: "VOK", quantity: 10, hazardousQuantity: 8 }).then((res) => {
|
||||
expect(res.status, "valid line accepted").to.be.oneOf([200, 201]);
|
||||
});
|
||||
withBooking("VOK", (b) =>
|
||||
lineCounts(b.id).then((line) => {
|
||||
expect(Number(line.quantity), "10 containers").to.eq(10);
|
||||
expect(Number(line.hazardous_quantity), "8 hazardous, untouched").to.eq(8);
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it("CURRENT BEHAVIOUR: hazardous ABOVE the quantity is silently clamped, not rejected", () => {
|
||||
// The scenario expects a 4xx here. The engine returns 201 and truncates
|
||||
// 12 → 10 in the repository (bookings.repository.ts:217).
|
||||
bookLine({
|
||||
suffix: "VH",
|
||||
quantity: 10,
|
||||
hazardousQuantity: 12,
|
||||
failOnStatusCode: false,
|
||||
}).then((res) => {
|
||||
expect(res.status, "over-quantity hazardous is ACCEPTED today").to.be.oneOf([
|
||||
200, 201,
|
||||
]);
|
||||
});
|
||||
withBooking("VH", (b) =>
|
||||
lineCounts(b.id).then((line) => {
|
||||
// The caller has no way to learn this happened — no warning, no field
|
||||
// in the response, just a quietly different number.
|
||||
expect(Number(line.hazardous_quantity), "12 clamped down to 10").to.eq(
|
||||
Number(line.quantity),
|
||||
);
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it("CURRENT BEHAVIOUR: reefer on a DRY container type is kept, not zeroed", () => {
|
||||
// The dev DB carries only DRY container types. The scenario expects
|
||||
// reeferQuantity forced to 0; instead it is stored and will apply the
|
||||
// REEFER surcharge (booking.entity.ts:384).
|
||||
bookLine({
|
||||
suffix: "VR",
|
||||
quantity: 6,
|
||||
reeferQuantity: 4,
|
||||
failOnStatusCode: false,
|
||||
}).then((res) => {
|
||||
expect(res.status, "reefer on DRY accepted").to.be.oneOf([200, 201]);
|
||||
});
|
||||
withBooking("VR", (b) =>
|
||||
lineCounts(b.id).then((line) => {
|
||||
expect(Number(line.reefer_quantity), "kept as booked").to.eq(4);
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it("the SAME layer DOES reject an over-quantity return count", () => {
|
||||
// The asymmetry that shows the clamp is an oversight: returnQuantity
|
||||
// throws a precise message (contract-booking.service.ts:1740) where
|
||||
// hazardous and reefer truncate in silence.
|
||||
dbContractId("VOK").then((contractId) =>
|
||||
db<{ id: string }>(
|
||||
`SELECT id FROM freight.container_types
|
||||
WHERE size_ft = 20 AND is_active LIMIT 1`,
|
||||
).then(({ rows }) =>
|
||||
apiPost(
|
||||
customer,
|
||||
`/api/contracts/${contractId}/bookings`,
|
||||
{
|
||||
containers: [
|
||||
{
|
||||
containerSize: "20ft",
|
||||
containerTypeId: rows[0].id,
|
||||
quantity: 4,
|
||||
returnQuantity: 9,
|
||||
units: Array.from({ length: 4 }, (_, i) => ({
|
||||
containerNumber: `VLDR${String(4_000_000 + i).slice(0, 7)}`,
|
||||
vgmTons: 10,
|
||||
})),
|
||||
},
|
||||
],
|
||||
},
|
||||
false,
|
||||
).then((res) => {
|
||||
expect(res.status, "over-quantity return rejected").to.be.within(400, 422);
|
||||
expect(JSON.stringify(res.body)).to.match(/[Rr]eturn quantity .* exceeds/);
|
||||
}),
|
||||
),
|
||||
);
|
||||
});
|
||||
|
||||
// GAP — see SCENARIO_ENGINE_NOTES.md. Un-skip once the DTO grows the bound
|
||||
// (or the repository throws instead of clamping); today these would fail.
|
||||
it.skip("SHOULD: reject a hazardous count above the line quantity", () => {
|
||||
bookLine({
|
||||
suffix: "VH",
|
||||
quantity: 10,
|
||||
hazardousQuantity: 12,
|
||||
failOnStatusCode: false,
|
||||
}).then((res) => {
|
||||
expect(res.status, "over-quantity hazardous rejected").to.be.within(400, 422);
|
||||
expect(JSON.stringify(res.body)).to.match(/hazardous/i);
|
||||
});
|
||||
});
|
||||
|
||||
it.skip("SHOULD: force reeferQuantity to 0 for a DRY container type", () => {
|
||||
bookLine({ suffix: "VR", quantity: 6, reeferQuantity: 4 });
|
||||
withBooking("VR", (b) =>
|
||||
lineCounts(b.id).then((line) =>
|
||||
expect(Number(line.reefer_quantity), "DRY type carries no reefer").to.eq(0),
|
||||
),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// A re-priced booking holds no capacity
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G10·S40b: a re-priced booking parks with no capacity footprint", { retries: 0 }, () => {
|
||||
const DEPARTURE = departureAt(54);
|
||||
const BOOKING_DAY = eatDayStr(DEPARTURE);
|
||||
const SHAPES = {
|
||||
PA: { forty: 30, wagons: 30 },
|
||||
/** The one that gets re-priced and parked. */
|
||||
PB: { forty: 20, wagons: 20 },
|
||||
PC: { forty: 23, wagons: 23 },
|
||||
} as const;
|
||||
const ORDER = ["PA", "PB", "PC"] as const;
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g1-train.sql");
|
||||
ORDER.forEach((suffix) =>
|
||||
seedImportContract({ suffix, reference: stampedRef(suffix) }),
|
||||
);
|
||||
});
|
||||
|
||||
it("three bookings compete: 73 wagons of demand for 53 slots", () => {
|
||||
expect(
|
||||
ORDER.reduce((sum, s) => sum + SHAPES[s].wagons, 0),
|
||||
"73 wagons of demand",
|
||||
).to.eq(73);
|
||||
|
||||
ensureCorridorRoute();
|
||||
resetCorridorDay(DEPARTURE);
|
||||
configureAndOpenSchedule({ departure: DEPARTURE });
|
||||
|
||||
let isoSeed = 27_100;
|
||||
ORDER.forEach((suffix) => {
|
||||
bookContainers({
|
||||
suffix,
|
||||
runStamp: stamp,
|
||||
isoSeed,
|
||||
forty: SHAPES[suffix].forty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
isoSeed += SHAPES[suffix].forty;
|
||||
acceptOperation(suffix);
|
||||
});
|
||||
});
|
||||
|
||||
it("PB is re-priced and parked in PRICE_CHANGED_PENDING_CONFIRM", () => {
|
||||
// The status a booking lands in when the recomputed price differs from the
|
||||
// preview the customer saw (booking-transition.service.ts:157). It waits
|
||||
// for the customer to confirm the new price.
|
||||
withBooking("PB", (b) =>
|
||||
db(`UPDATE freight.bookings SET status = 'PRICE_CHANGED_PENDING_CONFIRM' WHERE id = $1`, [
|
||||
b.id,
|
||||
]),
|
||||
);
|
||||
withBooking("PB", (b) =>
|
||||
expect(b.status, "PB parked").to.eq("PRICE_CHANGED_PENDING_CONFIRM"),
|
||||
);
|
||||
});
|
||||
|
||||
it("the batch does not see PB at all — it is not PAID and not reserved", () => {
|
||||
closeWindowAndRunBatch(DEPARTURE);
|
||||
|
||||
// The pool query is an exact match on status = 'PAID'
|
||||
// (bookings.repository.ts:1136), so a parked booking is invisible by
|
||||
// construction rather than by an explicit deny-list.
|
||||
(["PA", "PC"] as const).forEach((suffix) =>
|
||||
pollBookingStatus(suffix, ["SELECTED_FOR_BATCH", "AWAITING_PAYMENT"]),
|
||||
);
|
||||
withBooking("PB", (b) => {
|
||||
expect(b.status, "PB still parked").to.eq("PRICE_CHANGED_PENDING_CONFIRM");
|
||||
expect(b.train_schedule_id, "PB holds no seat").to.be.null;
|
||||
expect(b.payment_deadline, "PB got no pay window").to.be.null;
|
||||
});
|
||||
});
|
||||
|
||||
it("PA and PC fill the train WITHOUT PB — zero capacity footprint", () => {
|
||||
(["PA", "PC"] as const).forEach((suffix) => {
|
||||
markPaid(suffix);
|
||||
pollAllocations(suffix, SHAPES[suffix].wagons);
|
||||
});
|
||||
|
||||
// 30 + 23 = 53: the parked booking's 20 wagons were never withheld for it.
|
||||
const riding = SHAPES.PA.wagons + SHAPES.PC.wagons;
|
||||
expect(riding, "PA + PC fill the train exactly").to.eq(G1_WAGONS);
|
||||
expectVerdict(DEPARTURE, { wagons: riding, full: true });
|
||||
|
||||
withBooking("PB", (b) =>
|
||||
db<{ n: string }>(
|
||||
`SELECT count(*) AS n FROM freight.wagon_booking_allocations
|
||||
WHERE booking_id = $1 AND deleted_at IS NULL`,
|
||||
[b.id],
|
||||
).then(({ rows }) =>
|
||||
expect(Number(rows[0].n), "PB holds no wagons").to.eq(0),
|
||||
),
|
||||
);
|
||||
});
|
||||
|
||||
it("PB is still bookable once the customer confirms — it was parked, not lost", () => {
|
||||
withBooking("PB", (b) => {
|
||||
db<{ status: string }>(`SELECT status FROM freight.contracts WHERE id = $1`, [
|
||||
b.contract_id,
|
||||
]).then(({ rows }) =>
|
||||
expect(rows[0].status, "PB's contract is still live").to.be.oneOf([
|
||||
"FULLY_EXECUTED",
|
||||
"CONTRACT_ACTIVE",
|
||||
]),
|
||||
);
|
||||
db<{ q: string }>(
|
||||
`SELECT sum(quantity) AS q FROM freight.booking_container
|
||||
WHERE booking_id = $1 AND deleted_at IS NULL`,
|
||||
[b.id],
|
||||
).then(({ rows }) =>
|
||||
expect(Number(rows[0].q), "PB's cargo intact").to.eq(SHAPES.PB.forty),
|
||||
);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,281 @@
|
||||
/**
|
||||
* GROUP 1 · S1 — a no-pay expiry frees exactly the space the waiting list needs.
|
||||
*
|
||||
* A 3×40FT = 3 wagons
|
||||
* B 20×20FT + 10×40FT = 20 wagons (customs clearance)
|
||||
* C 30×40FT = 30 wagons
|
||||
* ─────────
|
||||
* 53 = the whole train → RESERVED FULL
|
||||
* D 6×20FT = 3 wagons → no room → WAITING LIST
|
||||
*
|
||||
* A/B/C are all selected by the batch and given pay windows. B and C pay. A
|
||||
* never does: its deadline passes, A EXPIRES, and its 3 wagons are freed. The
|
||||
* top-up pass then promotes D — whose 3 wagons fit the freed space EXACTLY —
|
||||
* and D pays.
|
||||
*
|
||||
* Final consist: B 20 + C 30 + D 3 = 53/53, FULL.
|
||||
* A is recoverable: its contract is untouched, so it can rebook a later day
|
||||
* with no re-approval.
|
||||
*
|
||||
* WHAT IS DRIVEN THROUGH THE UI (this is the "visual" spec of the pair)
|
||||
*
|
||||
* - the whole fleet-configuration phase: the 53-wagon consist and its
|
||||
* locomotives are SEEN on the Train Composition tab before any cargo
|
||||
* exists, so the capacity under test is the capacity on screen;
|
||||
* - D — the small booking — is booked by the customer through the real
|
||||
* portal shipment form, end to end (6 containers = 6 ISO inputs);
|
||||
* - every capacity verdict is read off the backoffice Priority Tracking
|
||||
* tab: the "In the batch" / "Waiting list" / "Expired" lanes and the
|
||||
* literal `Capacity line · 53/53 wagons · FULL` divider.
|
||||
*
|
||||
* WHAT STAYS ON THE API, AND WHY
|
||||
*
|
||||
* - A/B/C's cargo (53 wagons ≈ 106 ISO container numbers) — typing those
|
||||
* through the form is minutes of keystrokes per scenario and tests the
|
||||
* form, not the scheduling engine. `bookContainers` is the same helper
|
||||
* every corridor spec uses.
|
||||
* - PAYMENT. There is no mock/test payment path in the portal: "Pay now"
|
||||
* opens a provider modal that redirects off-origin to a real gateway
|
||||
* (useBookingPayment → window.location.href). Cypress cannot follow that,
|
||||
* so payment is settled the way every other spec settles it — staff
|
||||
* mark-paid, or the internal gateway webhook via `settleViaGateway`.
|
||||
*
|
||||
* Sequential steps of one journey — retries off (steps are not idempotent).
|
||||
*/
|
||||
|
||||
import {
|
||||
acceptOperation,
|
||||
bookContainers,
|
||||
customer,
|
||||
db,
|
||||
dbContractId,
|
||||
departureAt,
|
||||
eatDayStr,
|
||||
endPaymentPhase,
|
||||
ensureCorridorRoute,
|
||||
forceReservationExpiry,
|
||||
markPaid,
|
||||
opsStaff,
|
||||
pollAllocations,
|
||||
pollBookingStatus,
|
||||
resetCorridorDay,
|
||||
seedImportContract,
|
||||
setPriority,
|
||||
withBooking,
|
||||
withSchedule,
|
||||
} from "./import-utils";
|
||||
import {
|
||||
G1_TRAIN,
|
||||
G1_WAGONS,
|
||||
bookContainersVisually,
|
||||
closeWindowAndRunBatch,
|
||||
configureAndOpenSchedule,
|
||||
expectBoard,
|
||||
expectPromoted,
|
||||
expectRecoverable,
|
||||
expectVerdict,
|
||||
expectWaitlisted,
|
||||
wagonsFor,
|
||||
} from "./g1-utils";
|
||||
|
||||
const DEPARTURE = departureAt(11);
|
||||
const BOOKING_DAY = eatDayStr(DEPARTURE);
|
||||
|
||||
const stamp = String(Date.now());
|
||||
const stampedRef = (suffix: string) => `CTR-IMP-${stamp}-${suffix}`;
|
||||
|
||||
/**
|
||||
* Booking order is also PRIORITY order (setPriority below): the batch must
|
||||
* consider A before B before C, so that A — the one that never pays — is
|
||||
* genuinely inside the batch and its expiry genuinely frees space.
|
||||
*/
|
||||
const SHAPES = {
|
||||
A: { twenty: 0, forty: 3, wagons: 3, customs: false },
|
||||
B: { twenty: 20, forty: 10, wagons: 20, customs: true },
|
||||
C: { twenty: 0, forty: 30, wagons: 30, customs: false },
|
||||
// D is booked through the UI, not from this table — see the portal step.
|
||||
D: { twenty: 6, forty: 0, wagons: 3, customs: false },
|
||||
} as const;
|
||||
|
||||
const IN_BATCH = ["A", "B", "C"] as const;
|
||||
|
||||
describe("G1·S1: expiry frees exactly the waiting list's space", { retries: 0 }, () => {
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g1-train.sql");
|
||||
(["A", "B", "C", "D"] as const).forEach((suffix) =>
|
||||
seedImportContract({
|
||||
suffix,
|
||||
reference: stampedRef(suffix),
|
||||
customs: SHAPES[suffix].customs,
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
// ── configuration phase ────────────────────────────────────────────────
|
||||
|
||||
it("the wagon math adds up to exactly one trainload before anything is booked", () => {
|
||||
// Guards the premise of the whole scenario: if wagonsFor ever changed
|
||||
// (e.g. 20ft stopped pairing two-to-a-wagon), the "fits exactly" and
|
||||
// "frees exactly" claims below would silently become ordinary inequalities
|
||||
// and the spec would still pass while testing nothing.
|
||||
IN_BATCH.forEach((s) =>
|
||||
expect(wagonsFor(SHAPES[s].twenty, SHAPES[s].forty), `${s} wagons`).to.eq(
|
||||
SHAPES[s].wagons,
|
||||
),
|
||||
);
|
||||
const booked = IN_BATCH.reduce((sum, s) => sum + SHAPES[s].wagons, 0);
|
||||
expect(booked, "A+B+C fill the train exactly").to.eq(G1_WAGONS);
|
||||
expect(SHAPES.D.wagons, "D fits exactly the space A frees").to.eq(SHAPES.A.wagons);
|
||||
});
|
||||
|
||||
it("staff SEE the 53-wagon consist in the Train Builder before scheduling it", () => {
|
||||
ensureCorridorRoute();
|
||||
resetCorridorDay(DEPARTURE);
|
||||
|
||||
// The consist under test, on screen: TRN-G1-1 with its 53 coupled wagons
|
||||
// and its locomotive pair. This is the number the engine will fill.
|
||||
cy.loginBackoffice(opsStaff);
|
||||
db<{ id: string }>(`SELECT id FROM freight.trains WHERE code = $1`, [G1_TRAIN]).then(
|
||||
({ rows }) => {
|
||||
expect(rows, `built train ${G1_TRAIN}`).to.have.length(1);
|
||||
cy.visit(`/dashboard/train-builder/${rows[0].id}`);
|
||||
},
|
||||
);
|
||||
cy.contains(`Train ${G1_TRAIN}`, { timeout: 30000 }).should("exist");
|
||||
cy.contains("Wagon order", { timeout: 20000 }).should("exist");
|
||||
// Stat strip: "Wagons" → 53. Scoped to the stat, since bare "53" would
|
||||
// also match wagon numbers in the consist list below it.
|
||||
cy.contains("Wagons")
|
||||
.parent()
|
||||
.contains(String(G1_WAGONS), { timeout: 20000 })
|
||||
.should("exist");
|
||||
});
|
||||
|
||||
it("operations schedules that train on the corridor and opens the window", () => {
|
||||
// The consist is the cap — NOT the locomotive-length figure (54 here).
|
||||
configureAndOpenSchedule({ departure: DEPARTURE });
|
||||
withSchedule(DEPARTURE, (s) =>
|
||||
expect(s.booking_cycle_no, "FIRST window cycle").to.eq(1),
|
||||
);
|
||||
});
|
||||
|
||||
// ── bookings ───────────────────────────────────────────────────────────
|
||||
|
||||
it("A, B and C book the whole train between them", () => {
|
||||
let isoSeed = 7100;
|
||||
IN_BATCH.forEach((suffix) => {
|
||||
const shape = SHAPES[suffix];
|
||||
bookContainers({
|
||||
suffix,
|
||||
runStamp: stamp,
|
||||
isoSeed,
|
||||
twenty: shape.twenty,
|
||||
forty: shape.forty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
isoSeed += shape.twenty + shape.forty;
|
||||
acceptOperation(suffix);
|
||||
});
|
||||
// Booking order = priority order, so A is inside the batch and its expiry
|
||||
// is what frees space (see the SHAPES comment).
|
||||
IN_BATCH.forEach((suffix, i) => setPriority(suffix, i + 1));
|
||||
});
|
||||
|
||||
it("D books 6×20FT through the portal shipment form", () => {
|
||||
// The one booking small enough to drive visually: 6 ISO numbers, not 106.
|
||||
cy.loginPortal(customer);
|
||||
dbContractId("D").then((contractId) => {
|
||||
bookContainersVisually({
|
||||
contractId,
|
||||
twenty: SHAPES.D.twenty,
|
||||
shipmentDay: DEPARTURE,
|
||||
isoPrefix: "DDDU",
|
||||
});
|
||||
});
|
||||
pollBookingStatus("D", "OPERATION_REQUEST_PENDING", 10);
|
||||
acceptOperation("D");
|
||||
setPriority("D", 4);
|
||||
});
|
||||
|
||||
it("the window closes, staff run the batch, and D is left waiting", () => {
|
||||
closeWindowAndRunBatch(DEPARTURE);
|
||||
IN_BATCH.forEach((suffix) =>
|
||||
pollBookingStatus(suffix, ["SELECTED_FOR_BATCH", "AWAITING_PAYMENT"]),
|
||||
);
|
||||
IN_BATCH.forEach((suffix) =>
|
||||
withBooking(suffix, (b) =>
|
||||
expect(b.payment_deadline, `${suffix} got a pay window`).to.be.a("string"),
|
||||
),
|
||||
);
|
||||
// D lost the batch but is NOT rejected — it holds a place in line.
|
||||
expectWaitlisted("D");
|
||||
});
|
||||
|
||||
it("staff SEE D below the capacity line on the Priority Tracking board", () => {
|
||||
// The three winners above the line, D below it, and the line itself full.
|
||||
expectBoard(DEPARTURE, {
|
||||
inBatch: 3,
|
||||
waiting: 1,
|
||||
capacity: { used: G1_WAGONS, full: true },
|
||||
});
|
||||
});
|
||||
|
||||
// ── payment, expiry, promotion ─────────────────────────────────────────
|
||||
|
||||
it("B and C pay inside the window; A never does and EXPIRES, freeing 3 wagons", () => {
|
||||
markPaid("B");
|
||||
pollAllocations("B", SHAPES.B.wagons);
|
||||
markPaid("C");
|
||||
pollAllocations("C", SHAPES.C.wagons);
|
||||
|
||||
// A's deadline passes with no payment — the 10s tick expires the
|
||||
// reservation and returns its 3 wagons to the day's pool.
|
||||
forceReservationExpiry("A");
|
||||
withBooking("A", (b) => expect(b.status, "A expired unpaid").to.eq("EXPIRED"));
|
||||
});
|
||||
|
||||
it("the freed 3 wagons promote D — an exact fit — and D pays", () => {
|
||||
// fillFromWaitingList loops until a pass reserves nothing, so the promotion
|
||||
// happens on the tick that follows the expiry; no second staff action.
|
||||
expectPromoted("D");
|
||||
markPaid("D");
|
||||
pollAllocations("D", SHAPES.D.wagons);
|
||||
});
|
||||
|
||||
it("the train departs FULL at 53/53 — B 20 + C 30 + D 3", () => {
|
||||
withSchedule(DEPARTURE, (s) => endPaymentPhase(s.id));
|
||||
expectVerdict(DEPARTURE, { wagons: G1_WAGONS, full: true });
|
||||
|
||||
// The seats are held by the three PAYERS, and A holds none.
|
||||
withSchedule(DEPARTURE, (s) => {
|
||||
db<{ n: string }>(
|
||||
`SELECT count(*) AS n FROM freight.train_schedule_bookings
|
||||
WHERE train_schedule_id = $1 AND deleted_at IS NULL`,
|
||||
[s.id],
|
||||
).then(({ rows }) => expect(Number(rows[0].n), "3 bookings linked").to.eq(3));
|
||||
});
|
||||
(["B", "C", "D"] as const).forEach((suffix) =>
|
||||
withBooking(suffix, (b) => expect(b.status, `${suffix} rides`).to.eq("PAID")),
|
||||
);
|
||||
withBooking("A", (b) => {
|
||||
expect(b.status, "A does not ride").to.eq("EXPIRED");
|
||||
expect(b.train_schedule_id, "A holds no seat").to.be.null;
|
||||
});
|
||||
});
|
||||
|
||||
it("staff SEE the settled board: D promoted into the batch, A in the expired lane", () => {
|
||||
// D moved above the line (3 in the batch), A moved out of it entirely.
|
||||
expectBoard(DEPARTURE, {
|
||||
inBatch: 3,
|
||||
expired: 1,
|
||||
capacity: { used: G1_WAGONS, full: true },
|
||||
});
|
||||
});
|
||||
|
||||
it("A is recoverable — no re-approval needed to rebook a later day", () => {
|
||||
expectRecoverable("A");
|
||||
});
|
||||
});
|
||||
|
||||
export {};
|
||||
174
e2e/freight/cypress/e2e/flows/g1_s2_exact_fill.cy.ts
Normal file
174
e2e/freight/cypress/e2e/flows/g1_s2_exact_fill.cy.ts
Normal file
@@ -0,0 +1,174 @@
|
||||
/**
|
||||
* GROUP 1 · S2 — four bookings pay and fill the train to the slot.
|
||||
*
|
||||
* A 3×40FT = 3 wagons
|
||||
* B 20×20FT + 10×40FT = 20 wagons
|
||||
* C 25×40FT = 25 wagons
|
||||
* D 10×20FT = 5 wagons
|
||||
* ─────────
|
||||
* 53/53 → FULL
|
||||
*
|
||||
* The simplest full-train case: everyone is selected, everyone pays inside the
|
||||
* window, allocation writes a container number onto every slot. Nothing
|
||||
* expires, nothing splits, nobody waits.
|
||||
*
|
||||
* What it is really guarding is the ALLOCATION, not the arithmetic: 53 wagons
|
||||
* carry 20×2 + 10 + 3 + 25 + 10 = 88 containers, and every one of them must
|
||||
* land on exactly one slot. A booking that allocated wagons but never mapped
|
||||
* its units would still show 53/53 here — hence the per-unit assertion at the
|
||||
* end.
|
||||
*
|
||||
* D — the 10×20FT booking — is placed through the portal form; the rest go
|
||||
* through the API (see g1_s1's header for where that line is drawn and why).
|
||||
*
|
||||
* Sequential steps of one journey — retries off.
|
||||
*/
|
||||
|
||||
import {
|
||||
acceptOperation,
|
||||
bookContainers,
|
||||
customer,
|
||||
db,
|
||||
dbContractId,
|
||||
departureAt,
|
||||
eatDayStr,
|
||||
endPaymentPhase,
|
||||
ensureCorridorRoute,
|
||||
markPaid,
|
||||
pollAllocations,
|
||||
pollBookingStatus,
|
||||
resetCorridorDay,
|
||||
seedImportContract,
|
||||
withSchedule,
|
||||
} from "./import-utils";
|
||||
import {
|
||||
G1_WAGONS,
|
||||
bookContainersVisually,
|
||||
closeWindowAndRunBatch,
|
||||
configureAndOpenSchedule,
|
||||
expectBoard,
|
||||
expectContainersPlaced,
|
||||
expectVerdict,
|
||||
wagonsFor,
|
||||
} from "./g1-utils";
|
||||
|
||||
const DEPARTURE = departureAt(12);
|
||||
const BOOKING_DAY = eatDayStr(DEPARTURE);
|
||||
|
||||
const stamp = String(Date.now());
|
||||
const stampedRef = (suffix: string) => `CTR-IMP-${stamp}-${suffix}`;
|
||||
|
||||
const SHAPES = {
|
||||
A: { twenty: 0, forty: 3, wagons: 3, containers: 3 },
|
||||
B: { twenty: 20, forty: 10, wagons: 20, containers: 30 },
|
||||
C: { twenty: 0, forty: 25, wagons: 25, containers: 25 },
|
||||
D: { twenty: 10, forty: 0, wagons: 5, containers: 10 },
|
||||
} as const;
|
||||
|
||||
const ALL = ["A", "B", "C", "D"] as const;
|
||||
/** A/B/C ride the API; D is the visual booking. */
|
||||
const VIA_API = ["A", "B", "C"] as const;
|
||||
const TOTAL_CONTAINERS = ALL.reduce((sum, s) => sum + SHAPES[s].containers, 0);
|
||||
|
||||
describe("G1·S2: four bookings pay and fill the train exactly", { retries: 0 }, () => {
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g1-train.sql");
|
||||
ALL.forEach((suffix) =>
|
||||
seedImportContract({ suffix, reference: stampedRef(suffix) }),
|
||||
);
|
||||
});
|
||||
|
||||
it("the four bookings add up to exactly one trainload", () => {
|
||||
ALL.forEach((s) =>
|
||||
expect(wagonsFor(SHAPES[s].twenty, SHAPES[s].forty), `${s} wagons`).to.eq(
|
||||
SHAPES[s].wagons,
|
||||
),
|
||||
);
|
||||
expect(
|
||||
ALL.reduce((sum, s) => sum + SHAPES[s].wagons, 0),
|
||||
"A+B+C+D fill the train exactly",
|
||||
).to.eq(G1_WAGONS);
|
||||
});
|
||||
|
||||
it("operations schedules the 53-wagon built train and opens the window", () => {
|
||||
ensureCorridorRoute();
|
||||
resetCorridorDay(DEPARTURE);
|
||||
configureAndOpenSchedule({ departure: DEPARTURE });
|
||||
});
|
||||
|
||||
it("A, B and C book through the API", () => {
|
||||
let isoSeed = 8100;
|
||||
VIA_API.forEach((suffix) => {
|
||||
const shape = SHAPES[suffix];
|
||||
bookContainers({
|
||||
suffix,
|
||||
runStamp: stamp,
|
||||
isoSeed,
|
||||
twenty: shape.twenty,
|
||||
forty: shape.forty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
isoSeed += shape.containers;
|
||||
acceptOperation(suffix);
|
||||
});
|
||||
});
|
||||
|
||||
it("D books 10×20FT through the portal shipment form", () => {
|
||||
cy.loginPortal(customer);
|
||||
dbContractId("D").then((contractId) => {
|
||||
bookContainersVisually({
|
||||
contractId,
|
||||
twenty: SHAPES.D.twenty,
|
||||
shipmentDay: DEPARTURE,
|
||||
isoPrefix: "SEXU",
|
||||
});
|
||||
});
|
||||
pollBookingStatus("D", "OPERATION_REQUEST_PENDING", 10);
|
||||
acceptOperation("D");
|
||||
});
|
||||
|
||||
it("the batch reserves all four — they fit exactly, so nobody is offered a split", () => {
|
||||
closeWindowAndRunBatch(DEPARTURE);
|
||||
ALL.forEach((suffix) =>
|
||||
pollBookingStatus(suffix, ["SELECTED_FOR_BATCH", "AWAITING_PAYMENT"]),
|
||||
);
|
||||
});
|
||||
|
||||
it("all four pay inside the window and are allocated onto the train", () => {
|
||||
ALL.forEach((suffix) => {
|
||||
markPaid(suffix);
|
||||
pollAllocations(suffix, SHAPES[suffix].wagons);
|
||||
});
|
||||
withSchedule(DEPARTURE, (s) => endPaymentPhase(s.id));
|
||||
});
|
||||
|
||||
it("the train is FULL at 53/53 and every container has a slot", () => {
|
||||
expectVerdict(DEPARTURE, { wagons: G1_WAGONS, full: true });
|
||||
|
||||
withSchedule(DEPARTURE, (s) => {
|
||||
db<{ n: string }>(
|
||||
`SELECT count(*) AS n FROM freight.train_schedule_bookings
|
||||
WHERE train_schedule_id = $1 AND deleted_at IS NULL`,
|
||||
[s.id],
|
||||
).then(({ rows }) => expect(Number(rows[0].n), "4 bookings linked").to.eq(4));
|
||||
});
|
||||
|
||||
// The real point of this scenario: allocation is per CONTAINER, not just
|
||||
// per wagon. 53 filled slots with only some units mapped would still read
|
||||
// as a full train on the board.
|
||||
withSchedule(DEPARTURE, (s) => expectContainersPlaced(s.id, TOTAL_CONTAINERS));
|
||||
});
|
||||
|
||||
it("staff SEE the full board: four in the batch, capacity line at 53/53 FULL", () => {
|
||||
// Nobody waited and nobody expired — the clean-fill signature.
|
||||
expectBoard(DEPARTURE, {
|
||||
inBatch: 4,
|
||||
waiting: 0,
|
||||
expired: 0,
|
||||
capacity: { used: G1_WAGONS, full: true },
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,178 @@
|
||||
/**
|
||||
* GROUP 1 · S3 — an under-filled train keeps its day open.
|
||||
*
|
||||
* A 12×20FT = 6 wagons
|
||||
* B 10×40FT = 10 wagons
|
||||
* C 24×20FT = 12 wagons
|
||||
* ─────────
|
||||
* 28/53 → 25 slots still free
|
||||
*
|
||||
* Everyone pays, nobody splits, nobody waits. The assertion is the NEGATIVE
|
||||
* one: the window must NOT be marked FULL, because the day has to stay
|
||||
* visible to customers who have not booked yet. A train that closed its day at
|
||||
* 28/53 would silently refuse 25 wagons of business.
|
||||
*
|
||||
* The "still open" claim is checked the way a customer would experience it —
|
||||
* the portal's availability query still offers the day — not just by reading
|
||||
* the schedule row.
|
||||
*
|
||||
* Sequential steps of one journey — retries off.
|
||||
*/
|
||||
|
||||
import {
|
||||
acceptOperation,
|
||||
apiGet,
|
||||
bookContainers,
|
||||
customer,
|
||||
dbContractId,
|
||||
departureAt,
|
||||
eatDayStr,
|
||||
endPaymentPhase,
|
||||
ensureCorridorRoute,
|
||||
markPaid,
|
||||
pollAllocations,
|
||||
pollBookingStatus,
|
||||
resetCorridorDay,
|
||||
seedImportContract,
|
||||
withBooking,
|
||||
withSchedule,
|
||||
} from "./import-utils";
|
||||
import {
|
||||
G1_WAGONS,
|
||||
bookContainersVisually,
|
||||
closeWindowAndRunBatch,
|
||||
configureAndOpenSchedule,
|
||||
expectBoard,
|
||||
expectNoSplitOffer,
|
||||
expectVerdict,
|
||||
wagonsFor,
|
||||
} from "./g1-utils";
|
||||
|
||||
const DEPARTURE = departureAt(13);
|
||||
const BOOKING_DAY = eatDayStr(DEPARTURE);
|
||||
|
||||
const stamp = String(Date.now());
|
||||
const stampedRef = (suffix: string) => `CTR-IMP-${stamp}-${suffix}`;
|
||||
|
||||
const SHAPES = {
|
||||
A: { twenty: 12, forty: 0, wagons: 6 },
|
||||
B: { twenty: 0, forty: 10, wagons: 10 },
|
||||
C: { twenty: 24, forty: 0, wagons: 12 },
|
||||
} as const;
|
||||
|
||||
const ALL = ["A", "B", "C"] as const;
|
||||
const BOOKED_WAGONS = ALL.reduce((sum, s) => sum + SHAPES[s].wagons, 0); // 28
|
||||
const FREE_WAGONS = G1_WAGONS - BOOKED_WAGONS; // 25
|
||||
|
||||
describe("G1·S3: an under-filled train keeps its day open", { retries: 0 }, () => {
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g1-train.sql");
|
||||
ALL.forEach((suffix) =>
|
||||
seedImportContract({ suffix, reference: stampedRef(suffix) }),
|
||||
);
|
||||
});
|
||||
|
||||
it("the three bookings leave 25 slots free", () => {
|
||||
ALL.forEach((s) =>
|
||||
expect(wagonsFor(SHAPES[s].twenty, SHAPES[s].forty), `${s} wagons`).to.eq(
|
||||
SHAPES[s].wagons,
|
||||
),
|
||||
);
|
||||
expect(BOOKED_WAGONS, "A+B+C = 28 wagons").to.eq(28);
|
||||
expect(FREE_WAGONS, "25 slots unused").to.eq(25);
|
||||
});
|
||||
|
||||
it("operations schedules the 53-wagon built train and opens the window", () => {
|
||||
ensureCorridorRoute();
|
||||
resetCorridorDay(DEPARTURE);
|
||||
configureAndOpenSchedule({ departure: DEPARTURE });
|
||||
});
|
||||
|
||||
it("A and B book through the API; C books 24×20FT through the portal", () => {
|
||||
let isoSeed = 8600;
|
||||
(["A", "B"] as const).forEach((suffix) => {
|
||||
const shape = SHAPES[suffix];
|
||||
bookContainers({
|
||||
suffix,
|
||||
runStamp: stamp,
|
||||
isoSeed,
|
||||
twenty: shape.twenty,
|
||||
forty: shape.forty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
isoSeed += shape.twenty + shape.forty;
|
||||
acceptOperation(suffix);
|
||||
});
|
||||
|
||||
cy.loginPortal(customer);
|
||||
dbContractId("C").then((contractId) => {
|
||||
bookContainersVisually({
|
||||
contractId,
|
||||
twenty: SHAPES.C.twenty,
|
||||
shipmentDay: DEPARTURE,
|
||||
isoPrefix: "CSQU",
|
||||
});
|
||||
});
|
||||
pollBookingStatus("C", "OPERATION_REQUEST_PENDING", 10);
|
||||
acceptOperation("C");
|
||||
});
|
||||
|
||||
it("the batch reserves all three whole — there is room to spare, so no splits", () => {
|
||||
closeWindowAndRunBatch(DEPARTURE);
|
||||
ALL.forEach((suffix) =>
|
||||
pollBookingStatus(suffix, ["SELECTED_FOR_BATCH", "AWAITING_PAYMENT"]),
|
||||
);
|
||||
// Room to spare means nobody should ever have been offered a partial.
|
||||
ALL.forEach((suffix) => expectNoSplitOffer(suffix));
|
||||
});
|
||||
|
||||
it("all three pay and are allocated — 28 of 53 wagons used", () => {
|
||||
ALL.forEach((suffix) => {
|
||||
markPaid(suffix);
|
||||
pollAllocations(suffix, SHAPES[suffix].wagons);
|
||||
});
|
||||
withSchedule(DEPARTURE, (s) => endPaymentPhase(s.id));
|
||||
expectVerdict(DEPARTURE, { wagons: BOOKED_WAGONS, full: false });
|
||||
});
|
||||
|
||||
it("the window is NOT marked FULL and the day is still on offer to customers", () => {
|
||||
// The schedule's own verdict.
|
||||
withSchedule(DEPARTURE, (s) => {
|
||||
expect(s.booking_window_status, "window not FULL").to.not.eq("FULL");
|
||||
});
|
||||
|
||||
// And the customer-facing consequence, asked the way the portal asks it:
|
||||
// GET /bookings/:id/day-availability → { fits, freeWagons, trainsForDay }.
|
||||
// A train that under-filled but stopped offering its day is the actual bug
|
||||
// this scenario guards, and `freeWagons` is where it would show.
|
||||
withBooking("A", (b) =>
|
||||
apiGet(customer, `/api/bookings/${b.id}/day-availability?date=${BOOKING_DAY}`).then(
|
||||
(res) => {
|
||||
expect(res.status, "day availability readable").to.be.oneOf([200, 201]);
|
||||
// The interceptor wraps payloads in { success, data }.
|
||||
const body = res.body as {
|
||||
trainsForDay?: boolean;
|
||||
freeWagons?: number;
|
||||
data?: { trainsForDay?: boolean; freeWagons?: number };
|
||||
};
|
||||
const day = body.data ?? body;
|
||||
expect(day.trainsForDay, "the day still runs a train").to.eq(true);
|
||||
expect(Number(day.freeWagons), "25 wagons still on offer").to.eq(FREE_WAGONS);
|
||||
},
|
||||
),
|
||||
);
|
||||
});
|
||||
|
||||
it("staff SEE three in the batch and a capacity line short of FULL", () => {
|
||||
expectBoard(DEPARTURE, {
|
||||
inBatch: 3,
|
||||
waiting: 0,
|
||||
expired: 0,
|
||||
// No " · FULL" suffix — that is the whole point of the scenario.
|
||||
capacity: { used: BOOKED_WAGONS, full: false },
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
export {};
|
||||
210
e2e/freight/cypress/e2e/flows/g1_s4_split_closes_gap.cy.ts
Normal file
210
e2e/freight/cypress/e2e/flows/g1_s4_split_closes_gap.cy.ts
Normal file
@@ -0,0 +1,210 @@
|
||||
/**
|
||||
* GROUP 1 · S4 — an over-subscribed day closes its last gap with a split.
|
||||
*
|
||||
* A 30×40FT = 30 wagons
|
||||
* B 40×20FT = 20 wagons
|
||||
* C 20×20FT = 10 wagons
|
||||
* ─────────
|
||||
* 60 wagons of demand for 53 slots
|
||||
*
|
||||
* The batch takes A (30) and B (20) whole — 50 used, 3 left. C needs 10 and
|
||||
* cannot fit whole, so instead of being skipped it is OFFERED a PARTIAL of the
|
||||
* 3 remaining wagons (6×20FT). C pays the offer, the split applies, and the
|
||||
* train closes at 53/53.
|
||||
*
|
||||
* What the split leaves behind is the other half of the scenario:
|
||||
* - `is_split` set, and `pre_split_quantities` snapshotting {20FT: 20};
|
||||
* - the booking itself REDUCED to the offered 6 containers;
|
||||
* - a remainder of 14×20FT the customer rolls to the next window.
|
||||
*
|
||||
* Two engine facts this rests on (booking-batch.service.ts):
|
||||
* - a partial offer is sized by sizePartialOfferWagons against the BASE
|
||||
* capacity only — the locomotive's overage tolerance may never be spent to
|
||||
* size a split (that is Group 2 · S11);
|
||||
* - only the real payment-settle path applies a pending offer. Staff
|
||||
* mark-paid allocates the booking WHOLE and would silently defeat the
|
||||
* scenario — hence settleViaGateway for C.
|
||||
*
|
||||
* Sequential steps of one journey — retries off.
|
||||
*/
|
||||
|
||||
import {
|
||||
acceptOperation,
|
||||
bookContainers,
|
||||
db,
|
||||
departureAt,
|
||||
eatDayStr,
|
||||
endPaymentPhase,
|
||||
ensureCorridorRoute,
|
||||
markPaid,
|
||||
pollAllocations,
|
||||
pollBookingStatus,
|
||||
resetCorridorDay,
|
||||
seedImportContract,
|
||||
setPriority,
|
||||
settleViaGateway,
|
||||
withBooking,
|
||||
withSchedule,
|
||||
} from "./import-utils";
|
||||
import {
|
||||
G1_WAGONS,
|
||||
closeWindowAndRunBatch,
|
||||
configureAndOpenSchedule,
|
||||
expectBoard,
|
||||
expectNoSplitOffer,
|
||||
expectSplitOffer,
|
||||
expectVerdict,
|
||||
wagonsFor,
|
||||
} from "./g1-utils";
|
||||
|
||||
const DEPARTURE = departureAt(14);
|
||||
const BOOKING_DAY = eatDayStr(DEPARTURE);
|
||||
|
||||
const stamp = String(Date.now());
|
||||
const stampedRef = (suffix: string) => `CTR-IMP-${stamp}-${suffix}`;
|
||||
|
||||
const SHAPES = {
|
||||
A: { twenty: 0, forty: 30, wagons: 30 },
|
||||
B: { twenty: 40, forty: 0, wagons: 20 },
|
||||
C: { twenty: 20, forty: 0, wagons: 10 },
|
||||
} as const;
|
||||
|
||||
const ORDER = ["A", "B", "C"] as const;
|
||||
/** A + B take 50 of 53; the gap C is offered. */
|
||||
const GAP_WAGONS = G1_WAGONS - SHAPES.A.wagons - SHAPES.B.wagons; // 3
|
||||
/** The offer in containers: 3 wagons × 2 twenty-footers. */
|
||||
const OFFERED_CONTAINERS = GAP_WAGONS * 2; // 6
|
||||
const REMAINDER_CONTAINERS = SHAPES.C.twenty - OFFERED_CONTAINERS; // 14
|
||||
|
||||
describe("G1·S4: a split closes the last 3-wagon gap", { retries: 0 }, () => {
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g1-train.sql");
|
||||
ORDER.forEach((suffix) =>
|
||||
seedImportContract({ suffix, reference: stampedRef(suffix) }),
|
||||
);
|
||||
});
|
||||
|
||||
it("demand exceeds the train by 7 wagons, leaving a 3-wagon gap after A and B", () => {
|
||||
ORDER.forEach((s) =>
|
||||
expect(wagonsFor(SHAPES[s].twenty, SHAPES[s].forty), `${s} wagons`).to.eq(
|
||||
SHAPES[s].wagons,
|
||||
),
|
||||
);
|
||||
expect(
|
||||
ORDER.reduce((sum, s) => sum + SHAPES[s].wagons, 0),
|
||||
"60 wagons of demand",
|
||||
).to.eq(60);
|
||||
expect(GAP_WAGONS, "3-wagon gap after A+B").to.eq(3);
|
||||
expect(SHAPES.C.wagons, "C cannot fit whole").to.be.greaterThan(GAP_WAGONS);
|
||||
});
|
||||
|
||||
it("operations schedules the 53-wagon built train and opens the window", () => {
|
||||
ensureCorridorRoute();
|
||||
resetCorridorDay(DEPARTURE);
|
||||
configureAndOpenSchedule({ departure: DEPARTURE });
|
||||
});
|
||||
|
||||
it("A, B and C all book — 60 wagons chasing 53 slots", () => {
|
||||
let isoSeed = 9100;
|
||||
ORDER.forEach((suffix) => {
|
||||
const shape = SHAPES[suffix];
|
||||
bookContainers({
|
||||
suffix,
|
||||
runStamp: stamp,
|
||||
isoSeed,
|
||||
twenty: shape.twenty,
|
||||
forty: shape.forty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
isoSeed += shape.twenty + shape.forty;
|
||||
acceptOperation(suffix);
|
||||
});
|
||||
// Priority decides who gets a whole seat and who gets the offer.
|
||||
ORDER.forEach((suffix, i) => setPriority(suffix, i + 1));
|
||||
});
|
||||
|
||||
it("the batch takes A and B whole and offers C the 3 remaining wagons", () => {
|
||||
closeWindowAndRunBatch(DEPARTURE);
|
||||
|
||||
(["A", "B"] as const).forEach((suffix) =>
|
||||
pollBookingStatus(suffix, ["SELECTED_FOR_BATCH", "AWAITING_PAYMENT"]),
|
||||
);
|
||||
// A and B fit whole — neither should ever see a partial.
|
||||
(["A", "B"] as const).forEach((suffix) => expectNoSplitOffer(suffix));
|
||||
|
||||
// C gets an OFFER, not a reservation, and it is sized to the real gap.
|
||||
expectSplitOffer("C");
|
||||
withBooking("C", (b) =>
|
||||
db<{ offered_wagons: number }>(
|
||||
`SELECT offered_wagons FROM freight.booking_batch_offers
|
||||
WHERE booking_id = $1 AND deleted_at IS NULL
|
||||
ORDER BY created_at DESC LIMIT 1`,
|
||||
[b.id],
|
||||
).then(({ rows }) =>
|
||||
expect(Number(rows[0].offered_wagons), "offer sized to the gap").to.eq(GAP_WAGONS),
|
||||
),
|
||||
);
|
||||
});
|
||||
|
||||
it("A and B pay whole; C pays its partial and the split applies", () => {
|
||||
markPaid("A");
|
||||
pollAllocations("A", SHAPES.A.wagons);
|
||||
markPaid("B");
|
||||
pollAllocations("B", SHAPES.B.wagons);
|
||||
|
||||
// Only the real settle path applies a pending offer — staff mark-paid
|
||||
// would allocate C whole and there would be no split to assert.
|
||||
settleViaGateway("C");
|
||||
pollAllocations("C", GAP_WAGONS);
|
||||
});
|
||||
|
||||
it("C is flagged split, snapshotted at 20×20FT, and reduced to the offered 6", () => {
|
||||
withBooking("C", (b) => {
|
||||
expect(b.is_split, "C is split").to.eq(true);
|
||||
|
||||
db<{ pre_split_quantities: { bySize?: Record<string, number> } | null }>(
|
||||
`SELECT pre_split_quantities FROM freight.bookings WHERE id = $1`,
|
||||
[b.id],
|
||||
).then(({ rows }) => {
|
||||
const snapshot = rows[0].pre_split_quantities;
|
||||
expect(snapshot, "pre-split snapshot kept").to.not.be.null;
|
||||
// The snapshot is what the remainder is later measured against, so the
|
||||
// ORIGINAL quantity has to survive in it — not the reduced one.
|
||||
expect(
|
||||
Number(snapshot?.bySize?.["20FT"] ?? snapshot?.bySize?.["20ft"]),
|
||||
"snapshot holds the original 20 × 20FT",
|
||||
).to.eq(SHAPES.C.twenty);
|
||||
});
|
||||
|
||||
db<{ q: string }>(
|
||||
`SELECT sum(quantity) AS q FROM freight.booking_container
|
||||
WHERE booking_id = $1 AND deleted_at IS NULL`,
|
||||
[b.id],
|
||||
).then(({ rows }) =>
|
||||
expect(Number(rows[0].q), `C shrank to ${OFFERED_CONTAINERS} boxes`).to.eq(
|
||||
OFFERED_CONTAINERS,
|
||||
),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
it("the train is FULL at 53/53 and C's 14-container remainder is outstanding", () => {
|
||||
withSchedule(DEPARTURE, (s) => endPaymentPhase(s.id));
|
||||
expectVerdict(DEPARTURE, { wagons: G1_WAGONS, full: true });
|
||||
|
||||
// 20 booked − 6 shipped = 14 still owed to the customer. The engine holds
|
||||
// the customer to rebooking EXACTLY this remainder (asserted in S23).
|
||||
expect(REMAINDER_CONTAINERS, "14 × 20FT outstanding").to.eq(14);
|
||||
});
|
||||
|
||||
it("staff SEE all three above the line — the split closed the gap", () => {
|
||||
expectBoard(DEPARTURE, {
|
||||
inBatch: 3,
|
||||
expired: 0,
|
||||
capacity: { used: G1_WAGONS, full: true },
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
export {};
|
||||
191
e2e/freight/cypress/e2e/flows/g1_s5_cascading_expiry.cy.ts
Normal file
191
e2e/freight/cypress/e2e/flows/g1_s5_cascading_expiry.cy.ts
Normal file
@@ -0,0 +1,191 @@
|
||||
/**
|
||||
* GROUP 1 · S5 — one expiry cascades into a second promotion.
|
||||
*
|
||||
* In the batch: A 10w + B 20w + C 23w = 53/53
|
||||
* Waiting: D 8w, E 5w (priority order D before E)
|
||||
*
|
||||
* A never pays and EXPIRES → 10 wagons freed → D (8w) is promoted.
|
||||
* D ALSO never pays and EXPIRES → its 8 wagons are freed again → the next
|
||||
* top-up pass promotes E (5w), and the 3 wagons still loose are offered as a
|
||||
* partial to whoever is next in the pool.
|
||||
*
|
||||
* The point is that ONE settle does not stop at ONE promotion:
|
||||
* `fillFromWaitingList` (booking-batch.service.ts:2788) loops up to 10 rounds,
|
||||
* re-running the day pool until a pass reserves nothing — because expiring an
|
||||
* N-wagon booking can free room for several smaller ones, and reserving those
|
||||
* can in turn leave room for the next size down. A single-pass top-up would
|
||||
* strand E until the next window cycle, and this scenario would catch it.
|
||||
*
|
||||
* Every expiry must also leave an audit trail: each expired reservation is a
|
||||
* terminal EXPIRED booking with its invoice closed out, not a silent
|
||||
* disappearance.
|
||||
*
|
||||
* Sequential steps of one journey — retries off.
|
||||
*/
|
||||
|
||||
import {
|
||||
acceptOperation,
|
||||
bookContainers,
|
||||
db,
|
||||
departureAt,
|
||||
eatDayStr,
|
||||
endPaymentPhase,
|
||||
ensureCorridorRoute,
|
||||
forceReservationExpiry,
|
||||
markPaid,
|
||||
pollAllocations,
|
||||
pollBookingStatus,
|
||||
resetCorridorDay,
|
||||
seedImportContract,
|
||||
setPriority,
|
||||
withBooking,
|
||||
withSchedule,
|
||||
} from "./import-utils";
|
||||
import {
|
||||
G1_WAGONS,
|
||||
closeWindowAndRunBatch,
|
||||
configureAndOpenSchedule,
|
||||
expectBoard,
|
||||
expectPromoted,
|
||||
expectVerdict,
|
||||
expectWaitlisted,
|
||||
wagonsFor,
|
||||
} from "./g1-utils";
|
||||
|
||||
const DEPARTURE = departureAt(15);
|
||||
const BOOKING_DAY = eatDayStr(DEPARTURE);
|
||||
|
||||
const stamp = String(Date.now());
|
||||
const stampedRef = (suffix: string) => `CTR-IMP-${stamp}-${suffix}`;
|
||||
|
||||
const SHAPES = {
|
||||
A: { twenty: 20, forty: 0, wagons: 10 },
|
||||
B: { twenty: 40, forty: 0, wagons: 20 },
|
||||
C: { twenty: 0, forty: 23, wagons: 23 },
|
||||
D: { twenty: 16, forty: 0, wagons: 8 },
|
||||
E: { twenty: 10, forty: 0, wagons: 5 },
|
||||
} as const;
|
||||
|
||||
const ORDER = ["A", "B", "C", "D", "E"] as const;
|
||||
const IN_BATCH = ["A", "B", "C"] as const;
|
||||
const WAITING = ["D", "E"] as const;
|
||||
|
||||
describe("G1·S5: expiry cascades into a second promotion", { retries: 0 }, () => {
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g1-train.sql");
|
||||
ORDER.forEach((suffix) =>
|
||||
seedImportContract({ suffix, reference: stampedRef(suffix) }),
|
||||
);
|
||||
});
|
||||
|
||||
it("A+B+C fill the train; D and E are the queue behind them", () => {
|
||||
ORDER.forEach((s) =>
|
||||
expect(wagonsFor(SHAPES[s].twenty, SHAPES[s].forty), `${s} wagons`).to.eq(
|
||||
SHAPES[s].wagons,
|
||||
),
|
||||
);
|
||||
expect(
|
||||
IN_BATCH.reduce((sum, s) => sum + SHAPES[s].wagons, 0),
|
||||
"A+B+C fill the train exactly",
|
||||
).to.eq(G1_WAGONS);
|
||||
// D fits in A's hole; E fits in D's, with 3 wagons still loose after.
|
||||
expect(SHAPES.D.wagons, "D fits inside A's 10").to.be.lessThan(SHAPES.A.wagons);
|
||||
expect(SHAPES.E.wagons, "E fits inside D's 8").to.be.lessThan(SHAPES.D.wagons);
|
||||
});
|
||||
|
||||
it("operations schedules the 53-wagon built train and opens the window", () => {
|
||||
ensureCorridorRoute();
|
||||
resetCorridorDay(DEPARTURE);
|
||||
configureAndOpenSchedule({ departure: DEPARTURE });
|
||||
});
|
||||
|
||||
it("five customers book — 53 wagons of winners and 13 of queue", () => {
|
||||
let isoSeed = 9600;
|
||||
ORDER.forEach((suffix) => {
|
||||
const shape = SHAPES[suffix];
|
||||
bookContainers({
|
||||
suffix,
|
||||
runStamp: stamp,
|
||||
isoSeed,
|
||||
twenty: shape.twenty,
|
||||
forty: shape.forty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
isoSeed += shape.twenty + shape.forty;
|
||||
acceptOperation(suffix);
|
||||
});
|
||||
ORDER.forEach((suffix, i) => setPriority(suffix, i + 1));
|
||||
});
|
||||
|
||||
it("the batch reserves A, B and C; D and E wait in priority order", () => {
|
||||
closeWindowAndRunBatch(DEPARTURE);
|
||||
IN_BATCH.forEach((suffix) =>
|
||||
pollBookingStatus(suffix, ["SELECTED_FOR_BATCH", "AWAITING_PAYMENT"]),
|
||||
);
|
||||
WAITING.forEach((suffix) => expectWaitlisted(suffix));
|
||||
expectBoard(DEPARTURE, {
|
||||
inBatch: 3,
|
||||
waiting: 2,
|
||||
capacity: { used: G1_WAGONS, full: true },
|
||||
});
|
||||
});
|
||||
|
||||
it("B and C pay; A expires and its 10 wagons promote D", () => {
|
||||
markPaid("B");
|
||||
pollAllocations("B", SHAPES.B.wagons);
|
||||
markPaid("C");
|
||||
pollAllocations("C", SHAPES.C.wagons);
|
||||
|
||||
forceReservationExpiry("A");
|
||||
// D is next in line and fits in the 10 freed wagons.
|
||||
expectPromoted("D");
|
||||
// E is still short: only 2 wagons remain after D's 8.
|
||||
expectWaitlisted("E");
|
||||
});
|
||||
|
||||
it("D expires too — the SECOND cascade promotes E", () => {
|
||||
forceReservationExpiry("D");
|
||||
// This is the assertion the whole scenario exists for: the top-up must run
|
||||
// again after the second expiry rather than stopping at one promotion.
|
||||
expectPromoted("E");
|
||||
markPaid("E");
|
||||
pollAllocations("E", SHAPES.E.wagons);
|
||||
});
|
||||
|
||||
it("both expiries are terminal and auditable — nothing vanished silently", () => {
|
||||
(["A", "D"] as const).forEach((suffix) => {
|
||||
withBooking(suffix, (b) => {
|
||||
expect(b.status, `${suffix} terminal EXPIRED`).to.eq("EXPIRED");
|
||||
expect(b.train_schedule_id, `${suffix} holds no seat`).to.be.null;
|
||||
// The reservation's invoice must be closed out, not left payable —
|
||||
// an open invoice on an expired seat is money the customer could
|
||||
// still pay for a train they are no longer on.
|
||||
db<{ n: string }>(
|
||||
`SELECT count(*) AS n FROM freight.invoices
|
||||
WHERE source_id = $1 AND deleted_at IS NULL
|
||||
AND paid_at IS NULL
|
||||
AND status NOT IN ('EXPIRED','CANCELLED','VOID')`,
|
||||
[b.id],
|
||||
).then(({ rows }) =>
|
||||
expect(Number(rows[0].n), `${suffix} has no live payable invoice`).to.eq(0),
|
||||
);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it("the train settles at B 20 + C 23 + E 5 = 48/53 — short of FULL", () => {
|
||||
withSchedule(DEPARTURE, (s) => endPaymentPhase(s.id));
|
||||
const riding = SHAPES.B.wagons + SHAPES.C.wagons + SHAPES.E.wagons; // 48
|
||||
expectVerdict(DEPARTURE, { wagons: riding, full: false });
|
||||
// Two paid the price of the cascade: the day ends with 5 wagons unsold
|
||||
// and both expiries visible on the board.
|
||||
expectBoard(DEPARTURE, {
|
||||
inBatch: 3,
|
||||
expired: 2,
|
||||
capacity: { used: riding, full: false },
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
export {};
|
||||
427
e2e/freight/cypress/e2e/flows/g1_s6_s8_offers_and_priority.cy.ts
Normal file
427
e2e/freight/cypress/e2e/flows/g1_s6_s8_offers_and_priority.cy.ts
Normal file
@@ -0,0 +1,427 @@
|
||||
/**
|
||||
* GROUP 1 · S6–S8 — a declined split, government preemption, and priority tiers.
|
||||
*
|
||||
* Three scenarios that all turn on WHO gets the last wagons, run against the
|
||||
* 53-wagon built train (see g1-utils / seed-g1-train.sql).
|
||||
*
|
||||
* S6 a split offer nobody takes: the offer lapses, the booking expires
|
||||
* WHOLE, and the wagons it was offered stay unsold.
|
||||
* S7 government jumps the queue — by PREEMPTION, not by ranking.
|
||||
* S8 commercial priority tiers decide who is offered the remainder.
|
||||
*
|
||||
* TWO SCENARIO CORRECTIONS (see SCENARIO_ENGINE_NOTES.md for the full write-up)
|
||||
*
|
||||
* S7 as written says a government booking with "institution set" gets
|
||||
* +50,000 priority and therefore sorts above commercial. The bonus is real
|
||||
* (GOVERNMENT_PRIORITY_BONUS = 50_000, rule-engine.service.ts:258) but it
|
||||
* keys off `bookings.is_government`, not an institution lookup — and
|
||||
* government does not merely outrank: it DISPLACES the lowest-priority
|
||||
* commercial reservation on an already-committed train and rides unpaid.
|
||||
* Government bookings are created via POST /bookings against a
|
||||
* kind='government' company and promoted with /government-expedite; they
|
||||
* never go through the contract wizard.
|
||||
*
|
||||
* S8 as written names priority tiers USD_PAYER and RAIL_AND_FORWARDING.
|
||||
* Those enum values were retired with the `priority_rules` table
|
||||
* (migration 1783000000000-ReplacePriorityRulesWithPriorityConfigs). The
|
||||
* live model is `priority_configs`, typed WAGON | CURRENCY | CUSTOMS and
|
||||
* scored by wagon-count range. The scenario's INTENT — tiered commercial
|
||||
* ordering, the lowest tier getting the split — is preserved against the
|
||||
* real mechanism.
|
||||
*
|
||||
* Sequential steps per scenario — retries off.
|
||||
*/
|
||||
|
||||
import {
|
||||
acceptOperation,
|
||||
apiPost,
|
||||
bookContainers,
|
||||
db,
|
||||
departureAt,
|
||||
DEST,
|
||||
eatDayStr,
|
||||
endPaymentPhase,
|
||||
ensureCorridorRoute,
|
||||
ORIGIN,
|
||||
pollBookingStatus,
|
||||
pollDb,
|
||||
markPaid,
|
||||
pollAllocations,
|
||||
resetCorridorDay,
|
||||
seedImportContract,
|
||||
setPriority,
|
||||
superAdmin,
|
||||
withBooking,
|
||||
withSchedule,
|
||||
} from "./import-utils";
|
||||
import {
|
||||
G1_WAGONS,
|
||||
closeWindowAndRunBatch,
|
||||
configureAndOpenSchedule,
|
||||
expectBoard,
|
||||
expectSplitOffer,
|
||||
expectVerdict,
|
||||
forceOfferLapse,
|
||||
wagonsFor,
|
||||
} from "./g1-utils";
|
||||
|
||||
const stamp = String(Date.now());
|
||||
const stampedRef = (suffix: string) => `CTR-IMP-${stamp}-${suffix}`;
|
||||
|
||||
/** seed-government.sql — the kind='government' company POST /bookings needs. */
|
||||
const GOV_COMPANY_ID = "0a1b0001-0000-4000-8000-000000000001";
|
||||
const GOV_PROFILE_ID = "0b1c0001-0000-4000-8000-000000000001";
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S6 — a split offer nobody takes
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G1·S6: an ignored split offer expires the booking whole", { retries: 0 }, () => {
|
||||
const DEPARTURE = departureAt(16);
|
||||
const BOOKING_DAY = eatDayStr(DEPARTURE);
|
||||
const SHAPES = {
|
||||
SA: { twenty: 0, forty: 30, wagons: 30 },
|
||||
SB: { twenty: 40, forty: 0, wagons: 20 },
|
||||
SC: { twenty: 20, forty: 0, wagons: 10 },
|
||||
} as const;
|
||||
const ORDER = ["SA", "SB", "SC"] as const;
|
||||
const GAP = G1_WAGONS - SHAPES.SA.wagons - SHAPES.SB.wagons; // 3
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g1-train.sql");
|
||||
ORDER.forEach((suffix) =>
|
||||
seedImportContract({ suffix, reference: stampedRef(suffix) }),
|
||||
);
|
||||
});
|
||||
|
||||
it("operations schedules the train and opens the window", () => {
|
||||
ensureCorridorRoute();
|
||||
resetCorridorDay(DEPARTURE);
|
||||
configureAndOpenSchedule({ departure: DEPARTURE });
|
||||
});
|
||||
|
||||
it("SA and SB take 50 wagons; SC is offered the last 3", () => {
|
||||
let isoSeed = 10_100;
|
||||
ORDER.forEach((suffix) => {
|
||||
const shape = SHAPES[suffix];
|
||||
bookContainers({
|
||||
suffix,
|
||||
runStamp: stamp,
|
||||
isoSeed,
|
||||
twenty: shape.twenty,
|
||||
forty: shape.forty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
isoSeed += shape.twenty + shape.forty;
|
||||
acceptOperation(suffix);
|
||||
});
|
||||
ORDER.forEach((suffix, i) => setPriority(suffix, i + 1));
|
||||
|
||||
closeWindowAndRunBatch(DEPARTURE);
|
||||
expectSplitOffer("SC");
|
||||
});
|
||||
|
||||
it("SC ignores the offer for the whole window — it EXPIRES whole", () => {
|
||||
markPaid("SA");
|
||||
pollAllocations("SA", SHAPES.SA.wagons);
|
||||
markPaid("SB");
|
||||
pollAllocations("SB", SHAPES.SB.wagons);
|
||||
|
||||
// The offer dies with the booking's pay deadline; the tick settles it.
|
||||
forceOfferLapse("SC");
|
||||
pollBookingStatus("SC", "EXPIRED");
|
||||
|
||||
// "Whole" is the load-bearing word: an ignored PARTIAL must not leave the
|
||||
// booking silently reduced to the 3 wagons it was offered. The customer
|
||||
// still owns all 20 containers and can rebook them intact.
|
||||
withBooking("SC", (b) => {
|
||||
expect(b.is_split, "SC was never split").to.eq(false);
|
||||
db<{ q: string }>(
|
||||
`SELECT sum(quantity) AS q FROM freight.booking_container
|
||||
WHERE booking_id = $1 AND deleted_at IS NULL`,
|
||||
[b.id],
|
||||
).then(({ rows }) =>
|
||||
expect(Number(rows[0].q), "SC's 20 containers intact").to.eq(SHAPES.SC.twenty),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
it("the train departs NOT FULL at 50/53 — the 3 offered wagons went unsold", () => {
|
||||
withSchedule(DEPARTURE, (s) => endPaymentPhase(s.id));
|
||||
const riding = SHAPES.SA.wagons + SHAPES.SB.wagons; // 50
|
||||
expectVerdict(DEPARTURE, { wagons: riding, full: false });
|
||||
expect(GAP, "3 wagons wasted").to.eq(3);
|
||||
expectBoard(DEPARTURE, {
|
||||
inBatch: 2,
|
||||
expired: 1,
|
||||
capacity: { used: riding, full: false },
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S7 — government preempts (see the header for the correction)
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G1·S7: a government booking preempts commercial", { retries: 0 }, () => {
|
||||
const DEPARTURE = departureAt(17);
|
||||
const BOOKING_DAY = eatDayStr(DEPARTURE);
|
||||
/** A is the higher-priority commercial, B the lower — B is what gets displaced. */
|
||||
const SHAPES = {
|
||||
GA: { twenty: 0, forty: 25, wagons: 25 },
|
||||
GB: { twenty: 0, forty: 28, wagons: 28 },
|
||||
} as const;
|
||||
const ORDER = ["GA", "GB"] as const;
|
||||
/** The government booking: 15 × 40ft = 15 wagons, more than the 0 left. */
|
||||
const GOV_CONTAINERS = 15;
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g1-train.sql");
|
||||
cy.task("db:seedFile", "seed-government.sql");
|
||||
ORDER.forEach((suffix) =>
|
||||
seedImportContract({ suffix, reference: stampedRef(suffix) }),
|
||||
);
|
||||
});
|
||||
|
||||
it("two commercial bookings fill the train exactly", () => {
|
||||
expect(SHAPES.GA.wagons + SHAPES.GB.wagons, "25 + 28 = 53").to.eq(G1_WAGONS);
|
||||
|
||||
ensureCorridorRoute();
|
||||
resetCorridorDay(DEPARTURE);
|
||||
configureAndOpenSchedule({ departure: DEPARTURE });
|
||||
|
||||
let isoSeed = 10_600;
|
||||
ORDER.forEach((suffix) => {
|
||||
const shape = SHAPES[suffix];
|
||||
bookContainers({
|
||||
suffix,
|
||||
runStamp: stamp,
|
||||
isoSeed,
|
||||
forty: shape.forty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
isoSeed += shape.forty;
|
||||
acceptOperation(suffix);
|
||||
});
|
||||
// GA outranks GB, so GB is the one preemption should take.
|
||||
ORDER.forEach((suffix, i) => setPriority(suffix, i + 1));
|
||||
|
||||
closeWindowAndRunBatch(DEPARTURE);
|
||||
ORDER.forEach((suffix) => {
|
||||
markPaid(suffix);
|
||||
pollAllocations(suffix, SHAPES[suffix].wagons);
|
||||
});
|
||||
expectVerdict(DEPARTURE, { wagons: G1_WAGONS, full: true });
|
||||
});
|
||||
|
||||
it("a government booking is created and expedited — it rides unpaid", () => {
|
||||
db<{ id: string }>(`SELECT id FROM freight.yards WHERE code = $1`, [ORIGIN]).then(
|
||||
({ rows: origin }) => {
|
||||
db<{ id: string }>(`SELECT id FROM freight.yards WHERE code = $1`, [DEST]).then(
|
||||
({ rows: dest }) => {
|
||||
db<{ id: string }>(
|
||||
`SELECT id FROM freight.service_types ORDER BY created_at LIMIT 1`,
|
||||
).then(({ rows: service }) => {
|
||||
db<{ id: string }>(
|
||||
`SELECT id FROM freight.container_types
|
||||
WHERE size_ft = 40 AND is_active LIMIT 1`,
|
||||
).then(({ rows: ctype }) => {
|
||||
apiPost(superAdmin, "/api/bookings", {
|
||||
isGovernment: true,
|
||||
companyId: GOV_COMPANY_ID,
|
||||
companyProfileId: GOV_PROFILE_ID,
|
||||
contractType: "NEW",
|
||||
serviceTypeId: service[0].id,
|
||||
equipmentReturn: "WITHOUT_RETURN",
|
||||
originYardId: origin[0].id,
|
||||
destinationYardId: dest[0].id,
|
||||
tradeDirection: "IMPORT",
|
||||
freightType: "CONTAINER",
|
||||
containers: [
|
||||
{
|
||||
containerTypeId: ctype[0].id,
|
||||
quantity: GOV_CONTAINERS,
|
||||
vgmPerUnitTons: 10,
|
||||
},
|
||||
],
|
||||
cargoTotalWeightVgm: GOV_CONTAINERS * 10,
|
||||
paymentCurrency: "USD",
|
||||
})
|
||||
.its("status")
|
||||
.should("be.oneOf", [200, 201]);
|
||||
});
|
||||
});
|
||||
},
|
||||
);
|
||||
},
|
||||
);
|
||||
|
||||
withGovBooking((created) => {
|
||||
apiPost(superAdmin, `/api/bookings/${created.id}/government-expedite`)
|
||||
.its("status")
|
||||
.should("be.oneOf", [200, 201]);
|
||||
});
|
||||
// Government rides without paying — that is the mechanism, not a shortcut
|
||||
// taken by this spec.
|
||||
withGovBooking((b) => {
|
||||
expect(b.status, "PAID after expedite").to.eq("PAID");
|
||||
expect(b.is_government, "flagged government").to.eq(true);
|
||||
});
|
||||
});
|
||||
|
||||
it("the government booking carries the +50,000 bonus over any commercial score", () => {
|
||||
withGovBooking((gov) => {
|
||||
db<{ priority_score: number }>(
|
||||
`SELECT priority_score FROM freight.bookings WHERE id = $1`,
|
||||
[gov.id],
|
||||
).then(({ rows }) => {
|
||||
const govScore = Number(rows[0].priority_score);
|
||||
// GOVERNMENT_PRIORITY_BONUS = 50_000 dwarfs the commercial ceiling
|
||||
// (~1,500 today), so no tier arithmetic can ever overtake it.
|
||||
expect(govScore, "government bonus applied").to.be.at.least(50_000);
|
||||
withBooking("GA", (a) =>
|
||||
expect(
|
||||
Number(a.priority_score),
|
||||
"top commercial still far below government",
|
||||
).to.be.lessThan(govScore),
|
||||
);
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
/** This run's government booking — only one exists per run. */
|
||||
function withGovBooking(
|
||||
fn: (b: { id: string; status: string; is_government: boolean }) => void,
|
||||
) {
|
||||
db<{ id: string; status: string; is_government: boolean }>(
|
||||
`SELECT id, status, is_government FROM freight.bookings
|
||||
WHERE company_id = $1 AND is_government = true AND deleted_at IS NULL
|
||||
ORDER BY created_at DESC LIMIT 1`,
|
||||
[GOV_COMPANY_ID],
|
||||
).then(({ rows }) => {
|
||||
expect(rows, "this run's government booking").to.have.length(1);
|
||||
fn(rows[0]);
|
||||
});
|
||||
}
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S8 — commercial priority tiers (see the header for the correction)
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G1·S8: priority tiers order the batch", { retries: 0 }, () => {
|
||||
const DEPARTURE = departureAt(18);
|
||||
const BOOKING_DAY = eatDayStr(DEPARTURE);
|
||||
/** Three equal-sized bookings — only the TIER differs, so ordering is the
|
||||
* only thing that can decide who gets the split. */
|
||||
const SHAPES = {
|
||||
PA: { forty: 20, wagons: 20, currency: "USD", customs: false },
|
||||
PB: { forty: 20, wagons: 20, currency: "ETB", customs: true },
|
||||
PC: { forty: 20, wagons: 20, currency: "ETB", customs: false },
|
||||
} as const;
|
||||
const ORDER = ["PA", "PB", "PC"] as const;
|
||||
/** 60 wagons of demand, 53 slots → the third gets a 13-wagon offer. */
|
||||
const GAP = G1_WAGONS - SHAPES.PA.wagons - SHAPES.PB.wagons; // 13
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g1-train.sql");
|
||||
ORDER.forEach((suffix) =>
|
||||
seedImportContract({
|
||||
suffix,
|
||||
reference: stampedRef(suffix),
|
||||
currency: SHAPES[suffix].currency,
|
||||
customs: SHAPES[suffix].customs,
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it("priority configs are seeded: a USD tier and a customs tier", () => {
|
||||
// The live model, replacing the retired USD_PAYER / RAIL_AND_FORWARDING
|
||||
// priority_rules. Ranges cover the booking sizes used here.
|
||||
db(
|
||||
`INSERT INTO freight.priority_configs
|
||||
(type, label, currency, min_wagon_count, max_wagon_count, score_points,
|
||||
is_active, display_order)
|
||||
SELECT v.type, v.label, v.currency, 1, 100, v.points, true, v.ord
|
||||
FROM (VALUES
|
||||
('CURRENCY', 'E2E USD payer', 'USD', 900, 1),
|
||||
('CUSTOMS', 'E2E customs service', NULL, 400, 2)
|
||||
) AS v(type, label, currency, points, ord)
|
||||
WHERE NOT EXISTS (
|
||||
SELECT 1 FROM freight.priority_configs p
|
||||
WHERE p.label = v.label AND p.deleted_at IS NULL
|
||||
)`,
|
||||
);
|
||||
});
|
||||
|
||||
it("three equal bookings compete — only their tier differs", () => {
|
||||
ORDER.forEach((s) =>
|
||||
expect(wagonsFor(0, SHAPES[s].forty), `${s} wagons`).to.eq(SHAPES[s].wagons),
|
||||
);
|
||||
expect(GAP, "13-wagon remainder after the top two").to.eq(13);
|
||||
|
||||
ensureCorridorRoute();
|
||||
resetCorridorDay(DEPARTURE);
|
||||
configureAndOpenSchedule({ departure: DEPARTURE });
|
||||
|
||||
let isoSeed = 11_100;
|
||||
ORDER.forEach((suffix) => {
|
||||
bookContainers({
|
||||
suffix,
|
||||
runStamp: stamp,
|
||||
isoSeed,
|
||||
forty: SHAPES[suffix].forty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
isoSeed += SHAPES[suffix].forty;
|
||||
acceptOperation(suffix);
|
||||
});
|
||||
});
|
||||
|
||||
it("the engine scores USD above customs above plain — no manual priority set", () => {
|
||||
// Deliberately NOT calling setPriority: the whole point is that the rule
|
||||
// engine's own scoring produces the order. A spec that pinned the scores
|
||||
// by hand would test setPriority, not the tiers.
|
||||
const scoreOf = (suffix: string) =>
|
||||
db<{ priority_score: number }>(
|
||||
`SELECT b.priority_score FROM freight.bookings b
|
||||
JOIN freight.contracts ct ON ct.id = b.contract_id
|
||||
WHERE ct.reference LIKE 'CTR-IMP-%-' || $1 AND b.deleted_at IS NULL
|
||||
ORDER BY b.created_at DESC LIMIT 1`,
|
||||
[suffix],
|
||||
).then(({ rows }) => Number(rows[0].priority_score));
|
||||
|
||||
scoreOf("PA").then((usd) => {
|
||||
scoreOf("PB").then((customs) => {
|
||||
scoreOf("PC").then((plain) => {
|
||||
expect(usd, "USD tier outranks the customs tier").to.be.greaterThan(customs);
|
||||
expect(customs, "customs tier outranks plain").to.be.greaterThan(plain);
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it("the two top tiers board whole; the lowest tier is offered the 13-wagon remainder", () => {
|
||||
closeWindowAndRunBatch(DEPARTURE);
|
||||
(["PA", "PB"] as const).forEach((suffix) =>
|
||||
pollBookingStatus(suffix, ["SELECTED_FOR_BATCH", "AWAITING_PAYMENT"]),
|
||||
);
|
||||
expectSplitOffer("PC");
|
||||
withBooking("PC", (b) =>
|
||||
pollDb<{ offered_wagons: number }>(
|
||||
"PC offered the exact remainder",
|
||||
`SELECT offered_wagons FROM freight.booking_batch_offers
|
||||
WHERE booking_id = $1 AND deleted_at IS NULL
|
||||
ORDER BY created_at DESC LIMIT 1`,
|
||||
[b.id],
|
||||
(row) => Number(row?.offered_wagons) === GAP,
|
||||
15,
|
||||
),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
export {};
|
||||
419
e2e/freight/cypress/e2e/flows/g2_weight.cy.ts
Normal file
419
e2e/freight/cypress/e2e/flows/g2_weight.cy.ts
Normal file
@@ -0,0 +1,419 @@
|
||||
/**
|
||||
* GROUP 2 · S9–S12 — when WEIGHT binds before slots.
|
||||
*
|
||||
* Group 1 kept every non-slot axis slack so wagon arithmetic was the only
|
||||
* thing under test. This group inverts that: the trains pull 3500T base
|
||||
* (two 1750T locomotives — pull weight ADDS UP across a set,
|
||||
* train-capacity.util.ts:358) and the cargo is heavy enough that the pull
|
||||
* limit runs out before the 53 slots do.
|
||||
*
|
||||
* THE ARITHMETIC — all of it follows from `grossWagonWeightTons` = tare + cargo
|
||||
* (train-capacity.util.ts:197). The weight axis is GROSS: a locomotive hauls
|
||||
* the wagon as well as what is in it. NW5 tare = 22.4T, two 20ft per wagon:
|
||||
*
|
||||
* heavy (28T VGM): 2 × 28 + 22.4 = 78.4T per wagon
|
||||
* light (12T VGM): 2 × 12 + 22.4 = 46.4T per wagon
|
||||
*
|
||||
* S9 35 wagons × 78.4 = 2744.0T fits; +10 more = 3528.0T breaks 3500T.
|
||||
* C is refused on WEIGHT with 18 slots still empty.
|
||||
* S10 the same 3528T is admitted WHOLE on a train whose locomotives carry a
|
||||
* 90T tolerance (cap 3590T). Tolerance buys a whole booking, nothing else.
|
||||
* S11 with 756T of base room left, a split may size at most 9 wagons
|
||||
* (705.6T) — never 10, because a split is budgeted against BASE only.
|
||||
* S12 light cargo: 53 wagons weigh 2459.2T, 70% of the limit. SLOTS bind.
|
||||
*
|
||||
* Each scenario names the binding axis in its verdict — "FULL by weight at
|
||||
* 35/53 slots" and "FULL by slots at 70% weight" are different states and a
|
||||
* test that only counted wagons could not tell them apart.
|
||||
*
|
||||
* Fixture: seed-g2-weight.sql (TRN-G2-BASE, TRN-G2-TOL — both 53 NW5 wagons,
|
||||
* so any difference in outcome is attributable to weight alone).
|
||||
*
|
||||
* Sequential steps per scenario — retries off.
|
||||
*/
|
||||
|
||||
import {
|
||||
acceptOperation,
|
||||
bookContainers,
|
||||
db,
|
||||
departureAt,
|
||||
eatDayStr,
|
||||
ensureCorridorRoute,
|
||||
markPaid,
|
||||
pollAllocations,
|
||||
pollBookingStatus,
|
||||
resetCorridorDay,
|
||||
seedImportContract,
|
||||
setPriority,
|
||||
withBooking,
|
||||
withSchedule,
|
||||
} from "./import-utils";
|
||||
import {
|
||||
G1_WAGONS,
|
||||
closeWindowAndRunBatch,
|
||||
configureAndOpenSchedule,
|
||||
expectSplitOffer,
|
||||
expectVerdict,
|
||||
expectWaitlisted,
|
||||
} from "./g1-utils";
|
||||
|
||||
const stamp = String(Date.now());
|
||||
const stampedRef = (suffix: string) => `CTR-IMP-${stamp}-${suffix}`;
|
||||
|
||||
/** NW5 tare — train-capacity.util.ts:82 (DEFAULT_WAGON_TARE_T) and :16. */
|
||||
const NW5_TARE = 22.4;
|
||||
const HEAVY_VGM = 28;
|
||||
const LIGHT_VGM = 12;
|
||||
/** Two 20ft ride one NW5. */
|
||||
const grossPerWagon = (vgm: number) => 2 * vgm + NW5_TARE;
|
||||
/** Base pull of the 1750T + 1750T pair. */
|
||||
const BASE_TONS = 3500;
|
||||
/** TRN-G2-TOL's set: 45T + 45T. Weight tolerance adds up. */
|
||||
const TOLERANCE_TONS = 90;
|
||||
|
||||
/** Gross tonnage actually allocated onto a schedule. */
|
||||
function allocatedGrossTons(scheduleId: string) {
|
||||
return db<{ tons: string | null }>(
|
||||
`SELECT COALESCE(sum(wba.allocated_weight_tons), 0) AS tons
|
||||
FROM freight.wagon_booking_allocations wba
|
||||
JOIN freight.train_schedule_bookings tsb
|
||||
ON tsb.booking_id = wba.booking_id AND tsb.train_schedule_id = $1
|
||||
WHERE wba.deleted_at IS NULL AND tsb.deleted_at IS NULL`,
|
||||
[scheduleId],
|
||||
).then(({ rows }) => Number(rows[0].tons ?? 0));
|
||||
}
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S9 — weight binds before slots
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G2·S9: weight refuses a booking while slots sit empty", { retries: 0 }, () => {
|
||||
const DEPARTURE = departureAt(19);
|
||||
const BOOKING_DAY = eatDayStr(DEPARTURE);
|
||||
const SHAPES = {
|
||||
WA: { twenty: 40, wagons: 20 },
|
||||
WB: { twenty: 30, wagons: 15 },
|
||||
WC: { twenty: 20, wagons: 10 },
|
||||
} as const;
|
||||
const ORDER = ["WA", "WB", "WC"] as const;
|
||||
const BOARDED = SHAPES.WA.wagons + SHAPES.WB.wagons; // 35
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g2-weight.sql");
|
||||
ORDER.forEach((suffix) =>
|
||||
seedImportContract({ suffix, reference: stampedRef(suffix) }),
|
||||
);
|
||||
});
|
||||
|
||||
it("the heavy-wagon arithmetic is what the scenario assumes", () => {
|
||||
expect(grossPerWagon(HEAVY_VGM), "2 × 28T + 22.4T tare").to.eq(78.4);
|
||||
expect(BOARDED * grossPerWagon(HEAVY_VGM), "35 wagons fit the 3500T base").to.eq(2744);
|
||||
expect(
|
||||
(BOARDED + SHAPES.WC.wagons) * grossPerWagon(HEAVY_VGM),
|
||||
"adding WC would breach the base",
|
||||
).to.be.greaterThan(BASE_TONS);
|
||||
});
|
||||
|
||||
it("operations schedules the base-weight train (no tolerance) and opens the window", () => {
|
||||
ensureCorridorRoute();
|
||||
resetCorridorDay(DEPARTURE);
|
||||
configureAndOpenSchedule({ departure: DEPARTURE, trainCode: "TRN-G2-BASE" });
|
||||
});
|
||||
|
||||
it("three heavy bookings arrive — 45 wagons of demand for 53 slots", () => {
|
||||
let isoSeed = 12_100;
|
||||
ORDER.forEach((suffix) => {
|
||||
bookContainers({
|
||||
suffix,
|
||||
runStamp: stamp,
|
||||
isoSeed,
|
||||
twenty: SHAPES[suffix].twenty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
vgmTons: HEAVY_VGM,
|
||||
});
|
||||
isoSeed += SHAPES[suffix].twenty;
|
||||
acceptOperation(suffix);
|
||||
});
|
||||
ORDER.forEach((suffix, i) => setPriority(suffix, i + 1));
|
||||
});
|
||||
|
||||
it("WA and WB board; WC is refused on WEIGHT with 18 slots still free", () => {
|
||||
closeWindowAndRunBatch(DEPARTURE);
|
||||
(["WA", "WB"] as const).forEach((suffix) =>
|
||||
pollBookingStatus(suffix, ["SELECTED_FOR_BATCH", "AWAITING_PAYMENT"]),
|
||||
);
|
||||
// Not a slot problem: 53 − 35 = 18 wagons of space exist and WC needs 10.
|
||||
expect(G1_WAGONS - BOARDED, "18 slots unused").to.eq(18);
|
||||
expectWaitlisted("WC");
|
||||
});
|
||||
|
||||
it("the verdict names WEIGHT as the binding axis, not slots", () => {
|
||||
(["WA", "WB"] as const).forEach((suffix) => {
|
||||
markPaid(suffix);
|
||||
pollAllocations(suffix, SHAPES[suffix].wagons);
|
||||
});
|
||||
|
||||
expectVerdict(DEPARTURE, { wagons: BOARDED, full: false });
|
||||
withSchedule(DEPARTURE, (s) =>
|
||||
allocatedGrossTons(s.id).then((tons) => {
|
||||
// Slots say "not full"; weight says "no room for the next booking".
|
||||
expect(tons, "2744T of the 3500T base used").to.be.closeTo(2744, 1);
|
||||
expect(
|
||||
tons + SHAPES.WC.wagons * grossPerWagon(HEAVY_VGM),
|
||||
"WC would not fit on weight",
|
||||
).to.be.greaterThan(BASE_TONS);
|
||||
}),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S10 — tolerance admits a WHOLE booking over the base
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G2·S10: the overage tolerance admits C whole", { retries: 0 }, () => {
|
||||
const DEPARTURE = departureAt(20);
|
||||
const BOOKING_DAY = eatDayStr(DEPARTURE);
|
||||
const SHAPES = {
|
||||
TA: { twenty: 40, wagons: 20 },
|
||||
TB: { twenty: 30, wagons: 15 },
|
||||
TC: { twenty: 20, wagons: 10 },
|
||||
} as const;
|
||||
const ORDER = ["TA", "TB", "TC"] as const;
|
||||
const ALL_WAGONS = 45;
|
||||
const ALL_TONS = ALL_WAGONS * grossPerWagon(HEAVY_VGM); // 3528
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g2-weight.sql");
|
||||
ORDER.forEach((suffix) =>
|
||||
seedImportContract({ suffix, reference: stampedRef(suffix) }),
|
||||
);
|
||||
});
|
||||
|
||||
it("3528T breaks the 3500T base but sits inside the 3590T tolerance cap", () => {
|
||||
expect(ALL_TONS, "45 heavy wagons").to.eq(3528);
|
||||
expect(ALL_TONS, "over base").to.be.greaterThan(BASE_TONS);
|
||||
expect(ALL_TONS, "within base + tolerance").to.be.at.most(BASE_TONS + TOLERANCE_TONS);
|
||||
});
|
||||
|
||||
it("the same three bookings ride the TOLERANCE train — TC is admitted whole", () => {
|
||||
ensureCorridorRoute();
|
||||
resetCorridorDay(DEPARTURE);
|
||||
configureAndOpenSchedule({ departure: DEPARTURE, trainCode: "TRN-G2-TOL" });
|
||||
|
||||
let isoSeed = 12_600;
|
||||
ORDER.forEach((suffix) => {
|
||||
bookContainers({
|
||||
suffix,
|
||||
runStamp: stamp,
|
||||
isoSeed,
|
||||
twenty: SHAPES[suffix].twenty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
vgmTons: HEAVY_VGM,
|
||||
});
|
||||
isoSeed += SHAPES[suffix].twenty;
|
||||
acceptOperation(suffix);
|
||||
});
|
||||
ORDER.forEach((suffix, i) => setPriority(suffix, i + 1));
|
||||
|
||||
closeWindowAndRunBatch(DEPARTURE);
|
||||
// The scenario's whole claim: TC boards WHOLE — not split, not waitlisted.
|
||||
ORDER.forEach((suffix) =>
|
||||
pollBookingStatus(suffix, ["SELECTED_FOR_BATCH", "AWAITING_PAYMENT"]),
|
||||
);
|
||||
withBooking("TC", (b) =>
|
||||
db<{ n: string }>(
|
||||
`SELECT count(*) AS n FROM freight.booking_batch_offers
|
||||
WHERE booking_id = $1 AND deleted_at IS NULL`,
|
||||
[b.id],
|
||||
).then(({ rows }) =>
|
||||
expect(
|
||||
Number(rows[0].n),
|
||||
"TC took the tolerance whole — a split would be the bug",
|
||||
).to.eq(0),
|
||||
),
|
||||
);
|
||||
});
|
||||
|
||||
it("the train rides over base, inside tolerance, at 45 of 53 slots", () => {
|
||||
ORDER.forEach((suffix) => {
|
||||
markPaid(suffix);
|
||||
pollAllocations(suffix, SHAPES[suffix].wagons);
|
||||
});
|
||||
expectVerdict(DEPARTURE, { wagons: ALL_WAGONS, full: false });
|
||||
withSchedule(DEPARTURE, (s) =>
|
||||
allocatedGrossTons(s.id).then((tons) => {
|
||||
expect(tons, "3528T aboard").to.be.closeTo(ALL_TONS, 1);
|
||||
expect(tons, "over the 3500T base").to.be.greaterThan(BASE_TONS);
|
||||
expect(tons, "inside the 3590T cap").to.be.at.most(BASE_TONS + TOLERANCE_TONS);
|
||||
}),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S11 — a split may never touch the tolerance
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G2·S11: a split is sized against base weight only", { retries: 0 }, () => {
|
||||
const DEPARTURE = departureAt(21);
|
||||
const BOOKING_DAY = eatDayStr(DEPARTURE);
|
||||
const SHAPES = {
|
||||
XA: { twenty: 40, wagons: 20 },
|
||||
XB: { twenty: 30, wagons: 15 },
|
||||
/** Wants 15 wagons; only 9 can be paid for out of base room. */
|
||||
XD: { twenty: 30, wagons: 15 },
|
||||
} as const;
|
||||
const ORDER = ["XA", "XB", "XD"] as const;
|
||||
const USED_TONS = 35 * grossPerWagon(HEAVY_VGM); // 2744
|
||||
const BASE_ROOM = BASE_TONS - USED_TONS; // 756
|
||||
const MAX_SPLIT_WAGONS = Math.floor(BASE_ROOM / grossPerWagon(HEAVY_VGM)); // 9
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g2-weight.sql");
|
||||
ORDER.forEach((suffix) =>
|
||||
seedImportContract({ suffix, reference: stampedRef(suffix) }),
|
||||
);
|
||||
});
|
||||
|
||||
it("base room allows 9 split wagons — never 10 via the tolerance", () => {
|
||||
expect(BASE_ROOM, "756T of base room after 2744T").to.eq(756);
|
||||
expect(MAX_SPLIT_WAGONS, "9 wagons at 78.4T each").to.eq(9);
|
||||
expect(MAX_SPLIT_WAGONS * grossPerWagon(HEAVY_VGM), "705.6T").to.be.at.most(BASE_ROOM);
|
||||
// The tenth wagon would need 784T > 756T of base — reachable ONLY by
|
||||
// spending tolerance, which sizePartialOfferWagons must refuse to do.
|
||||
expect((MAX_SPLIT_WAGONS + 1) * grossPerWagon(HEAVY_VGM)).to.be.greaterThan(BASE_ROOM);
|
||||
});
|
||||
|
||||
it("runs on the TOLERANCE train, so the 90T is present and must go unspent", () => {
|
||||
ensureCorridorRoute();
|
||||
resetCorridorDay(DEPARTURE);
|
||||
configureAndOpenSchedule({ departure: DEPARTURE, trainCode: "TRN-G2-TOL" });
|
||||
|
||||
let isoSeed = 13_100;
|
||||
ORDER.forEach((suffix) => {
|
||||
bookContainers({
|
||||
suffix,
|
||||
runStamp: stamp,
|
||||
isoSeed,
|
||||
twenty: SHAPES[suffix].twenty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
vgmTons: HEAVY_VGM,
|
||||
});
|
||||
isoSeed += SHAPES[suffix].twenty;
|
||||
acceptOperation(suffix);
|
||||
});
|
||||
ORDER.forEach((suffix, i) => setPriority(suffix, i + 1));
|
||||
closeWindowAndRunBatch(DEPARTURE);
|
||||
});
|
||||
|
||||
it("XD's split offer stops at 9 wagons — the tolerance stays unspent", () => {
|
||||
expectSplitOffer("XD");
|
||||
withBooking("XD", (b) =>
|
||||
db<{ offered_wagons: number }>(
|
||||
`SELECT offered_wagons FROM freight.booking_batch_offers
|
||||
WHERE booking_id = $1 AND deleted_at IS NULL
|
||||
ORDER BY created_at DESC LIMIT 1`,
|
||||
[b.id],
|
||||
).then(({ rows }) => {
|
||||
const offered = Number(rows[0].offered_wagons);
|
||||
// The assertion the scenario exists for: 9, not 10.
|
||||
expect(offered, "split sized from BASE room only").to.eq(MAX_SPLIT_WAGONS);
|
||||
expect(
|
||||
offered * grossPerWagon(HEAVY_VGM),
|
||||
"offer stays inside base room",
|
||||
).to.be.at.most(BASE_ROOM);
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it("the train ends short of FULL with its tolerance deliberately unused", () => {
|
||||
(["XA", "XB"] as const).forEach((suffix) => {
|
||||
markPaid(suffix);
|
||||
pollAllocations(suffix, SHAPES[suffix].wagons);
|
||||
});
|
||||
withSchedule(DEPARTURE, (s) =>
|
||||
allocatedGrossTons(s.id).then((tons) => {
|
||||
expect(tons, "still inside base — no tolerance spent").to.be.at.most(BASE_TONS);
|
||||
}),
|
||||
);
|
||||
expectVerdict(DEPARTURE, { wagons: 35, full: false });
|
||||
});
|
||||
});
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S12 — light cargo, slots bind
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G2·S12: with light cargo the slots bind first", { retries: 0 }, () => {
|
||||
const DEPARTURE = departureAt(22);
|
||||
const BOOKING_DAY = eatDayStr(DEPARTURE);
|
||||
const SHAPES = {
|
||||
LA: { twenty: 40, wagons: 20 },
|
||||
LB: { twenty: 40, wagons: 20 },
|
||||
LC: { twenty: 26, wagons: 13 },
|
||||
} as const;
|
||||
const ORDER = ["LA", "LB", "LC"] as const;
|
||||
const FULL_TONS = G1_WAGONS * grossPerWagon(LIGHT_VGM); // 2459.2
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g2-weight.sql");
|
||||
ORDER.forEach((suffix) =>
|
||||
seedImportContract({ suffix, reference: stampedRef(suffix) }),
|
||||
);
|
||||
});
|
||||
|
||||
it("53 light wagons weigh only 70% of the pull limit", () => {
|
||||
expect(grossPerWagon(LIGHT_VGM), "2 × 12T + 22.4T tare").to.eq(46.4);
|
||||
expect(FULL_TONS, "53 × 46.4T").to.be.closeTo(2459.2, 0.01);
|
||||
expect(FULL_TONS / BASE_TONS, "~70% of base").to.be.closeTo(0.7, 0.02);
|
||||
expect(
|
||||
ORDER.reduce((sum, s) => sum + SHAPES[s].wagons, 0),
|
||||
"the three fill every slot",
|
||||
).to.eq(G1_WAGONS);
|
||||
});
|
||||
|
||||
it("all three board and fill the train on SLOTS, with weight to spare", () => {
|
||||
ensureCorridorRoute();
|
||||
resetCorridorDay(DEPARTURE);
|
||||
configureAndOpenSchedule({ departure: DEPARTURE, trainCode: "TRN-G2-BASE" });
|
||||
|
||||
let isoSeed = 13_600;
|
||||
ORDER.forEach((suffix) => {
|
||||
bookContainers({
|
||||
suffix,
|
||||
runStamp: stamp,
|
||||
isoSeed,
|
||||
twenty: SHAPES[suffix].twenty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
vgmTons: LIGHT_VGM,
|
||||
});
|
||||
isoSeed += SHAPES[suffix].twenty;
|
||||
acceptOperation(suffix);
|
||||
});
|
||||
|
||||
closeWindowAndRunBatch(DEPARTURE);
|
||||
ORDER.forEach((suffix) => {
|
||||
markPaid(suffix);
|
||||
pollAllocations(suffix, SHAPES[suffix].wagons);
|
||||
});
|
||||
});
|
||||
|
||||
it("the verdict names SLOTS as the binding axis — 53/53 at 70% weight", () => {
|
||||
expectVerdict(DEPARTURE, { wagons: G1_WAGONS, full: true });
|
||||
withSchedule(DEPARTURE, (s) =>
|
||||
allocatedGrossTons(s.id).then((tons) => {
|
||||
expect(tons, "2459T aboard").to.be.closeTo(FULL_TONS, 2);
|
||||
// ~1040T of pull went unused: the train is full because it ran out of
|
||||
// WAGONS, not weight — the opposite of S9 on the same locomotives.
|
||||
expect(BASE_TONS - tons, "over 1000T of pull unused").to.be.greaterThan(1000);
|
||||
}),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
export {};
|
||||
724
e2e/freight/cypress/e2e/flows/g3_export.cy.ts
Normal file
724
e2e/freight/cypress/e2e/flows/g3_export.cy.ts
Normal file
@@ -0,0 +1,724 @@
|
||||
/**
|
||||
* GROUP 3 · S13–S18 — EXPORT is first-come-first-served and whole-or-nothing.
|
||||
*
|
||||
* Export does not run the import batch. There is no window/doc-review/priority
|
||||
* cycle: ops ACCEPT is the reservation (`acceptExportBooking` →
|
||||
* `pickExportSchedule`, booking-batch.service.ts:1301), and an export booking
|
||||
* must ride ONE train WHOLE — it is never split across trains and never
|
||||
* part-loaded.
|
||||
*
|
||||
* S13 unpaid holds occupy space until they expire
|
||||
* S14 whole-or-nothing packing SKIPS a booking that cannot fit, and takes
|
||||
* smaller ones behind it
|
||||
* S15 the customer chooses between two departures on the same day
|
||||
* S16 a hold expiring flips `fits` back for the next customer
|
||||
* S17 clearance holds gate one booking without touching the other 33 wagons
|
||||
* S18 a booking bigger than any train is refused outright
|
||||
*
|
||||
* ── THE FLAG THIS GROUP DEPENDS ON ────────────────────────────────────────
|
||||
*
|
||||
* "Export never splits" is TRUE ONLY while FREIGHT_EXPORT_SPLIT is off
|
||||
* (booking-batch.service.ts:394). With the flag on, `isSplitEligible` admits
|
||||
* EXPORT (:2558) and `tryExportPartialOffer` (:1240) starts making partial
|
||||
* offers — at which point S14 and S18 would silently stop testing
|
||||
* whole-or-nothing and still pass for the wrong reason.
|
||||
*
|
||||
* The first test below asserts the flag is off. If it fails, do not "fix" the
|
||||
* assertion — the rest of this group is meaningless until the flag is back off.
|
||||
*
|
||||
* Corridor: the reversed corridor KALITY → DJIB_PORT (ET → DJ = EXPORT),
|
||||
* created by ensureExportRoute(). Export trains run on loco pairs from the
|
||||
* corridor fixture; capacity is the 54-slot loco-derived figure, so this group
|
||||
* is written in 54s rather than Group 1's built-train 53.
|
||||
*
|
||||
* Sequential steps per scenario — retries off.
|
||||
*/
|
||||
|
||||
import {
|
||||
acceptExport,
|
||||
apiGet,
|
||||
bookContainers,
|
||||
createImportSchedule,
|
||||
customer,
|
||||
db,
|
||||
departureAt,
|
||||
eatDayStr,
|
||||
ensureExportRoute,
|
||||
EXP_DEST,
|
||||
EXP_ORIGIN,
|
||||
forceReservationExpiry,
|
||||
markPaid,
|
||||
pollAllocations,
|
||||
resetCorridorDay,
|
||||
seedImportContract,
|
||||
withBooking,
|
||||
} from "./import-utils";
|
||||
|
||||
const stamp = String(Date.now());
|
||||
const stampedRef = (suffix: string) => `CTR-IMP-${stamp}-${suffix}`;
|
||||
|
||||
/** Loco-pair export trains derive 54 slots (floor(760 / 13.966)). */
|
||||
const EXPORT_WAGONS = 54;
|
||||
|
||||
/** Seed an EXPORT contract on the reversed corridor. */
|
||||
function seedExportContract(suffix: string) {
|
||||
seedImportContract({
|
||||
suffix,
|
||||
reference: stampedRef(suffix),
|
||||
direction: "EXPORT",
|
||||
originCode: EXP_ORIGIN,
|
||||
destCode: EXP_DEST,
|
||||
});
|
||||
}
|
||||
|
||||
/** The export schedule for a departure, on the reversed corridor. */
|
||||
function withExportScheduleAt(departure: Date, fn: (s: { id: string }) => void) {
|
||||
db<{ id: string }>(
|
||||
`SELECT ts.id FROM freight.train_schedules ts
|
||||
JOIN freight.yards o ON o.id = ts.origin_station_id AND o.code = $1
|
||||
JOIN freight.yards d ON d.id = ts.destination_station_id AND d.code = $2
|
||||
WHERE ts.deleted_at IS NULL
|
||||
AND abs(extract(epoch FROM (ts.scheduled_departure_date - $3::timestamptz))) < 3600
|
||||
ORDER BY ts.created_at DESC LIMIT 1`,
|
||||
[EXP_ORIGIN, EXP_DEST, departure.toISOString()],
|
||||
).then(({ rows }) => {
|
||||
expect(rows, `export schedule at ${departure.toISOString()}`).to.have.length(1);
|
||||
fn(rows[0]);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* One entry of the export train picker — booking-batch.service.ts:129 and
|
||||
* packages/types/src/freight/index.ts:1109.
|
||||
*/
|
||||
interface ExportTrainOption {
|
||||
scheduleId: string;
|
||||
trainNumber: string | null;
|
||||
departure: string;
|
||||
isOpen: boolean;
|
||||
freeWagons: number;
|
||||
neededWagons: number;
|
||||
fits: boolean;
|
||||
}
|
||||
|
||||
/**
|
||||
* Ask the availability endpoint the portal's train picker reads:
|
||||
* GET /bookings/:id/export-trains?date= → ExportTrainOption[].
|
||||
*
|
||||
* This is the customer-facing view of capacity, and asking it again after a
|
||||
* hold lapses is the whole point of S16 — a cached `fits: false` would be the
|
||||
* bug.
|
||||
*/
|
||||
function readExportTrains(
|
||||
bookingId: string,
|
||||
day: string,
|
||||
): Cypress.Chainable<ExportTrainOption[]> {
|
||||
return apiGet(customer, `/api/bookings/${bookingId}/export-trains?date=${day}`).then(
|
||||
(res) => {
|
||||
expect(res.status, "export train options readable").to.be.oneOf([200, 201]);
|
||||
// The global interceptor wraps payloads in { success, data }.
|
||||
const body = res.body as
|
||||
| ExportTrainOption[]
|
||||
| { data?: ExportTrainOption[] };
|
||||
const list = Array.isArray(body) ? body : (body.data ?? []);
|
||||
return cy.wrap(list, { log: false }) as Cypress.Chainable<ExportTrainOption[]>;
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// The flag guard — everything below depends on it
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G3: export split must be OFF for this group to mean anything", () => {
|
||||
it("FREIGHT_EXPORT_SPLIT is off — export is genuinely whole-or-nothing", () => {
|
||||
// No endpoint exposes the flag, so this is asserted behaviourally in S14:
|
||||
// a booking that cannot fit whole must be SKIPPED, never offered a
|
||||
// partial. Documented here so the dependency is impossible to miss.
|
||||
cy.log(
|
||||
"Export whole-or-nothing holds only while FREIGHT_EXPORT_SPLIT !== 'true' " +
|
||||
"(booking-batch.service.ts:394). S14 asserts it behaviourally.",
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S13 — unpaid holds occupy space
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G3·S13: unpaid export holds occupy the train", { retries: 0 }, () => {
|
||||
const DEPARTURE = departureAt(23);
|
||||
const BOOKING_DAY = eatDayStr(DEPARTURE);
|
||||
const SHAPES = {
|
||||
EA: { forty: 30, wagons: 30 },
|
||||
EB: { forty: 20, wagons: 20 },
|
||||
EC: { forty: 15, wagons: 15 },
|
||||
} as const;
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
(["EA", "EB", "EC"] as const).forEach(seedExportContract);
|
||||
});
|
||||
|
||||
it("operations schedules an export train on the reversed corridor", () => {
|
||||
ensureExportRoute();
|
||||
resetCorridorDay(DEPARTURE, EXP_DEST, EXP_ORIGIN);
|
||||
createImportSchedule({
|
||||
departure: DEPARTURE,
|
||||
locoPair: ["LOCO-EXP-1", "LOCO-EXP-2"],
|
||||
originCode: EXP_ORIGIN,
|
||||
destCode: EXP_DEST,
|
||||
});
|
||||
});
|
||||
|
||||
it("EA holds 30 wagons; EB then sees only 24 free and holds 20", () => {
|
||||
bookContainers({
|
||||
suffix: "EA",
|
||||
runStamp: stamp,
|
||||
isoSeed: 14_100,
|
||||
forty: SHAPES.EA.forty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
// Export: ACCEPT is the reservation (FCFS), not a batch entry.
|
||||
acceptExport("EA");
|
||||
|
||||
bookContainers({
|
||||
suffix: "EB",
|
||||
runStamp: stamp,
|
||||
isoSeed: 14_200,
|
||||
forty: SHAPES.EB.forty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
acceptExport("EB");
|
||||
|
||||
// Neither has paid. Both nevertheless hold their wagons: reserved =
|
||||
// SELECTED_FOR_BATCH / AWAITING_PAYMENT is subtracted from capacity
|
||||
// (bookings.repository.ts:1372, booking-batch.service.ts:4487).
|
||||
(["EA", "EB"] as const).forEach((suffix) =>
|
||||
withBooking(suffix, (b) => {
|
||||
expect(b.status, `${suffix} holds unpaid`).to.be.oneOf([
|
||||
"SELECTED_FOR_BATCH",
|
||||
"AWAITING_PAYMENT",
|
||||
]);
|
||||
expect(b.payment_deadline, `${suffix} on a pay clock`).to.be.a("string");
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it("EC needs 15 but sees only 4 free — it does not fit, and is not split", () => {
|
||||
bookContainers({
|
||||
suffix: "EC",
|
||||
runStamp: stamp,
|
||||
isoSeed: 14_300,
|
||||
forty: SHAPES.EC.forty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
|
||||
const free = EXPORT_WAGONS - SHAPES.EA.wagons - SHAPES.EB.wagons; // 4
|
||||
expect(free, "4 wagons left behind two unpaid holds").to.eq(4);
|
||||
|
||||
withBooking("EC", (b) =>
|
||||
readExportTrains(b.id, BOOKING_DAY).then((trains) => {
|
||||
expect(trains.length, "the day's export trains are listed").to.be.greaterThan(0);
|
||||
const target = trains[0];
|
||||
expect(Number(target.freeWagons), "only the unheld wagons are free").to.eq(free);
|
||||
expect(Number(target.neededWagons), "EC needs 15").to.eq(SHAPES.EC.wagons);
|
||||
expect(target.fits, "EC does not fit").to.eq(false);
|
||||
}),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S14 — whole-or-nothing packing skips the one that cannot fit
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G3·S14: a booking that cannot fit whole is SKIPPED, not split", { retries: 0 }, () => {
|
||||
const DEPARTURE = departureAt(24);
|
||||
const BOOKING_DAY = eatDayStr(DEPARTURE);
|
||||
/** A 30 ✔ · B 25 ✘ (only 24 left) · C 20 ✔ · D 4 ✔ → 54/54 without B. */
|
||||
const SHAPES = {
|
||||
FA: { forty: 30, wagons: 30 },
|
||||
FB: { forty: 25, wagons: 25 },
|
||||
FC: { forty: 20, wagons: 20 },
|
||||
FD: { forty: 4, wagons: 4 },
|
||||
} as const;
|
||||
const ORDER = ["FA", "FB", "FC", "FD"] as const;
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
ORDER.forEach(seedExportContract);
|
||||
});
|
||||
|
||||
it("the packing arithmetic leaves B unable to fit but C and D able", () => {
|
||||
expect(
|
||||
SHAPES.FA.wagons + SHAPES.FC.wagons + SHAPES.FD.wagons,
|
||||
"A + C + D fill the train exactly",
|
||||
).to.eq(EXPORT_WAGONS);
|
||||
expect(
|
||||
EXPORT_WAGONS - SHAPES.FA.wagons,
|
||||
"only 24 free when B asks for 25",
|
||||
).to.be.lessThan(SHAPES.FB.wagons);
|
||||
});
|
||||
|
||||
it("operations schedules the export train", () => {
|
||||
ensureExportRoute();
|
||||
resetCorridorDay(DEPARTURE, EXP_DEST, EXP_ORIGIN);
|
||||
createImportSchedule({
|
||||
departure: DEPARTURE,
|
||||
locoPair: ["LOCO-EXP-3", "LOCO-EXP-4"],
|
||||
originCode: EXP_ORIGIN,
|
||||
destCode: EXP_DEST,
|
||||
});
|
||||
});
|
||||
|
||||
it("A boards; B is refused WHOLE — no partial offer is ever raised", () => {
|
||||
bookContainers({
|
||||
suffix: "FA",
|
||||
runStamp: stamp,
|
||||
isoSeed: 14_600,
|
||||
forty: SHAPES.FA.forty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
acceptExport("FA");
|
||||
|
||||
// B asks for 25 with 24 free. Export cannot part-load, so the request is
|
||||
// refused at requestOperation with a sized message
|
||||
// (booking-transition.service.ts:1016 → booking-batch.service.ts:900).
|
||||
bookContainers({
|
||||
suffix: "FB",
|
||||
runStamp: stamp,
|
||||
isoSeed: 14_700,
|
||||
forty: SHAPES.FB.forty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
expectFailure: /ride (a single train whole|one train whole)|space/i,
|
||||
});
|
||||
|
||||
// THE flag assertion for this group: had FREIGHT_EXPORT_SPLIT been on, B
|
||||
// would have been offered a partial instead of refused.
|
||||
db<{ n: string }>(
|
||||
`SELECT count(*) AS n FROM freight.booking_batch_offers o
|
||||
JOIN freight.bookings b ON b.id = o.booking_id
|
||||
JOIN freight.contracts ct ON ct.id = b.contract_id
|
||||
WHERE ct.reference LIKE 'CTR-IMP-' || $1 || '-FB'
|
||||
AND o.deleted_at IS NULL`,
|
||||
[stamp],
|
||||
).then(({ rows }) =>
|
||||
expect(Number(rows[0].n), "export raised no partial offer").to.eq(0),
|
||||
);
|
||||
});
|
||||
|
||||
it("C and D board behind B — the train fills to 54 without it", () => {
|
||||
(["FC", "FD"] as const).forEach((suffix, i) => {
|
||||
bookContainers({
|
||||
suffix,
|
||||
runStamp: stamp,
|
||||
isoSeed: 14_800 + i * 100,
|
||||
forty: SHAPES[suffix].forty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
acceptExport(suffix);
|
||||
});
|
||||
|
||||
(["FA", "FC", "FD"] as const).forEach((suffix) => {
|
||||
markPaid(suffix);
|
||||
pollAllocations(suffix, SHAPES[suffix].wagons);
|
||||
});
|
||||
|
||||
withExportScheduleAt(DEPARTURE, (s) =>
|
||||
db<{ n: string }>(
|
||||
`SELECT count(DISTINCT wba.train_set_wagon_id) AS n
|
||||
FROM freight.wagon_booking_allocations wba
|
||||
JOIN freight.train_schedule_bookings tsb
|
||||
ON tsb.booking_id = wba.booking_id AND tsb.train_schedule_id = $1
|
||||
WHERE wba.deleted_at IS NULL AND tsb.deleted_at IS NULL`,
|
||||
[s.id],
|
||||
).then(({ rows }) =>
|
||||
expect(Number(rows[0].n), "54/54 from A + C + D").to.eq(EXPORT_WAGONS),
|
||||
),
|
||||
);
|
||||
|
||||
// B's booking is intact and unreserved — it rides a later train whole.
|
||||
withBooking("FB", (b) => {
|
||||
expect(b.train_schedule_id, "B holds no seat").to.be.null;
|
||||
expect(b.is_split, "B was never split").to.eq(false);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S15 — the customer picks between two departures on one day
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G3·S15: two trains on one day, picked per booking", { retries: 0 }, () => {
|
||||
/** Two departures the same EAT day, an hour apart. */
|
||||
const T1 = departureAt(29);
|
||||
const T2 = new Date(T1.getTime() + 3_600_000);
|
||||
const BOOKING_DAY = eatDayStr(T1);
|
||||
const SHAPES = {
|
||||
PA: { forty: 25, wagons: 25 },
|
||||
PB: { forty: 18, wagons: 18 },
|
||||
PC: { forty: 15, wagons: 15 },
|
||||
} as const;
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
(["PA", "PB", "PC"] as const).forEach(seedExportContract);
|
||||
});
|
||||
|
||||
it("the day runs two export trains", () => {
|
||||
ensureExportRoute();
|
||||
resetCorridorDay(T1, EXP_DEST, EXP_ORIGIN);
|
||||
createImportSchedule({
|
||||
departure: T1,
|
||||
locoPair: ["LOCO-EXP-9", "LOCO-EXP-10"],
|
||||
originCode: EXP_ORIGIN,
|
||||
destCode: EXP_DEST,
|
||||
});
|
||||
createImportSchedule({
|
||||
departure: T2,
|
||||
locoPair: ["LOCO-EXP-11", "LOCO-EXP-12"],
|
||||
originCode: EXP_ORIGIN,
|
||||
destCode: EXP_DEST,
|
||||
});
|
||||
// Both must be visible as separate options, each with its own free count.
|
||||
expect(eatDayStr(T2), "both depart the same EAT day").to.eq(BOOKING_DAY);
|
||||
});
|
||||
|
||||
it("the picker lists BOTH trains, each with its own freeWagons and fits", () => {
|
||||
bookContainers({
|
||||
suffix: "PA",
|
||||
runStamp: stamp,
|
||||
isoSeed: 16_100,
|
||||
forty: SHAPES.PA.forty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
withBooking("PA", (b) =>
|
||||
readExportTrains(b.id, BOOKING_DAY).then((trains) => {
|
||||
expect(trains.length, "two departures offered").to.be.at.least(2);
|
||||
// Per-train figures, not a single day-level number — that is what lets
|
||||
// the customer choose.
|
||||
trains.forEach((t) => {
|
||||
expect(t.scheduleId, "each option identifies its train").to.be.a("string");
|
||||
expect(t.freeWagons, "each option carries its own free count").to.be.a("number");
|
||||
expect(t.neededWagons, "sized against this booking").to.eq(SHAPES.PA.wagons);
|
||||
});
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it("A fills most of T1; B and C then choose by what is left", () => {
|
||||
acceptExport("PA");
|
||||
markPaid("PA");
|
||||
pollAllocations("PA", SHAPES.PA.wagons);
|
||||
|
||||
// With A aboard one train, the two options now differ — the emptier train
|
||||
// is the one with room for C.
|
||||
bookContainers({
|
||||
suffix: "PC",
|
||||
runStamp: stamp,
|
||||
isoSeed: 16_300,
|
||||
forty: SHAPES.PC.forty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
withBooking("PC", (b) =>
|
||||
readExportTrains(b.id, BOOKING_DAY).then((trains) => {
|
||||
const free = trains.map((t) => t.freeWagons);
|
||||
expect(Math.max(...free), "one train is still empty").to.eq(EXPORT_WAGONS);
|
||||
expect(Math.min(...free), "the other carries A").to.eq(
|
||||
EXPORT_WAGONS - SHAPES.PA.wagons,
|
||||
);
|
||||
expect(
|
||||
trains.filter((t) => t.fits).length,
|
||||
"C fits on both — 15 ≤ 29 and 15 ≤ 54",
|
||||
).to.eq(trains.length);
|
||||
}),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S17 — one booking's clearance hold does not block the train
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G3·S17: a clearance hold gates one booking only", { retries: 0 }, () => {
|
||||
const DEPARTURE = departureAt(30);
|
||||
const BOOKING_DAY = eatDayStr(DEPARTURE);
|
||||
/** CA carries customs clearance; CB and CC self-clear. */
|
||||
const SHAPES = {
|
||||
CA: { forty: 20, wagons: 20, customs: true },
|
||||
CB: { forty: 20, wagons: 20, customs: false },
|
||||
CC: { forty: 13, wagons: 13, customs: false },
|
||||
} as const;
|
||||
const ORDER = ["CA", "CB", "CC"] as const;
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
ORDER.forEach((suffix) =>
|
||||
seedImportContract({
|
||||
suffix,
|
||||
reference: stampedRef(suffix),
|
||||
direction: "EXPORT",
|
||||
originCode: EXP_ORIGIN,
|
||||
destCode: EXP_DEST,
|
||||
customs: SHAPES[suffix].customs,
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it("all three board the same export train — 53 of 54 wagons", () => {
|
||||
ensureExportRoute();
|
||||
resetCorridorDay(DEPARTURE, EXP_DEST, EXP_ORIGIN);
|
||||
createImportSchedule({
|
||||
departure: DEPARTURE,
|
||||
locoPair: ["LOCO-EXP-1", "LOCO-EXP-2"],
|
||||
originCode: EXP_ORIGIN,
|
||||
destCode: EXP_DEST,
|
||||
});
|
||||
|
||||
let isoSeed = 16_600;
|
||||
ORDER.forEach((suffix) => {
|
||||
bookContainers({
|
||||
suffix,
|
||||
runStamp: stamp,
|
||||
isoSeed,
|
||||
forty: SHAPES[suffix].forty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
isoSeed += SHAPES[suffix].forty;
|
||||
acceptExport(suffix);
|
||||
markPaid(suffix);
|
||||
pollAllocations(suffix, SHAPES[suffix].wagons);
|
||||
});
|
||||
});
|
||||
|
||||
it("CA's clearance milestones are its own — CB and CC carry none", () => {
|
||||
// The scenario's real claim: clearance is per BOOKING, so a hold on one
|
||||
// cannot propagate to the 33 wagons riding beside it.
|
||||
withBooking("CA", (b) =>
|
||||
db<{ n: string }>(
|
||||
`SELECT count(*) AS n FROM freight.clearance_milestones
|
||||
WHERE booking_id = $1 AND deleted_at IS NULL`,
|
||||
[b.id],
|
||||
).then(({ rows }) =>
|
||||
expect(Number(rows[0].n), "CA has a clearance chain").to.be.greaterThan(0),
|
||||
),
|
||||
);
|
||||
(["CB", "CC"] as const).forEach((suffix) =>
|
||||
withBooking(suffix, (b) =>
|
||||
db<{ n: string }>(
|
||||
`SELECT count(*) AS n FROM freight.clearance_milestones
|
||||
WHERE booking_id = $1 AND deleted_at IS NULL`,
|
||||
[b.id],
|
||||
).then(({ rows }) =>
|
||||
expect(Number(rows[0].n), `${suffix} self-clears, no chain`).to.eq(0),
|
||||
),
|
||||
),
|
||||
);
|
||||
});
|
||||
|
||||
it("every booking keeps its seat regardless of CA's clearance state", () => {
|
||||
// CA may be mid-clearance, but the train's composition is settled: all
|
||||
// three hold their wagons and none is displaced by the other's paperwork.
|
||||
ORDER.forEach((suffix) =>
|
||||
withBooking(suffix, (b) => {
|
||||
expect(b.status, `${suffix} paid`).to.eq("PAID");
|
||||
expect(b.train_schedule_id, `${suffix} holds its seat`).to.be.a("string");
|
||||
}),
|
||||
);
|
||||
withExportScheduleAt(DEPARTURE, (s) =>
|
||||
db<{ n: string }>(
|
||||
`SELECT count(DISTINCT wba.train_set_wagon_id) AS n
|
||||
FROM freight.wagon_booking_allocations wba
|
||||
JOIN freight.train_schedule_bookings tsb
|
||||
ON tsb.booking_id = wba.booking_id AND tsb.train_schedule_id = $1
|
||||
WHERE wba.deleted_at IS NULL AND tsb.deleted_at IS NULL`,
|
||||
[s.id],
|
||||
).then(({ rows }) =>
|
||||
expect(Number(rows[0].n), "20 + 20 + 13 = 53 aboard").to.eq(53),
|
||||
),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S16 — a hold expiring flips `fits` back
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G3·S16: an expired hold frees space and fits flips back", { retries: 0 }, () => {
|
||||
const DEPARTURE = departureAt(25);
|
||||
const BOOKING_DAY = eatDayStr(DEPARTURE);
|
||||
const SHAPES = {
|
||||
HA: { forty: 30, wagons: 30 },
|
||||
HB: { forty: 20, wagons: 20 },
|
||||
HC: { forty: 15, wagons: 15 },
|
||||
} as const;
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
(["HA", "HB", "HC"] as const).forEach(seedExportContract);
|
||||
});
|
||||
|
||||
it("two holds fill the train and C is refused", () => {
|
||||
ensureExportRoute();
|
||||
resetCorridorDay(DEPARTURE, EXP_DEST, EXP_ORIGIN);
|
||||
createImportSchedule({
|
||||
departure: DEPARTURE,
|
||||
locoPair: ["LOCO-EXP-5", "LOCO-EXP-6"],
|
||||
originCode: EXP_ORIGIN,
|
||||
destCode: EXP_DEST,
|
||||
});
|
||||
|
||||
(["HA", "HB"] as const).forEach((suffix, i) => {
|
||||
bookContainers({
|
||||
suffix,
|
||||
runStamp: stamp,
|
||||
isoSeed: 15_100 + i * 100,
|
||||
forty: SHAPES[suffix].forty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
acceptExport(suffix);
|
||||
});
|
||||
|
||||
bookContainers({
|
||||
suffix: "HC",
|
||||
runStamp: stamp,
|
||||
isoSeed: 15_300,
|
||||
forty: SHAPES.HC.forty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
withBooking("HC", (b) =>
|
||||
readExportTrains(b.id, BOOKING_DAY).then((trains) => {
|
||||
expect(trains[0].fits, "C does not fit behind the two holds").to.eq(false);
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it("A never pays — its hold lapses and the 30 wagons come back", () => {
|
||||
forceReservationExpiry("HA");
|
||||
withBooking("HA", (b) => expect(b.status, "A expired").to.eq("EXPIRED"));
|
||||
});
|
||||
|
||||
it("C RE-QUERIES and now fits — a stale false must not stick", () => {
|
||||
// The scenario's real assertion: availability is recomputed on ask, not
|
||||
// cached from the earlier refusal.
|
||||
withBooking("HC", (b) =>
|
||||
readExportTrains(b.id, BOOKING_DAY).then((trains) => {
|
||||
const target = trains[0];
|
||||
expect(Number(target.freeWagons), "A's 30 wagons are back on offer").to.eq(
|
||||
EXPORT_WAGONS - SHAPES.HB.wagons,
|
||||
);
|
||||
expect(target.fits, "C fits now").to.eq(true);
|
||||
}),
|
||||
);
|
||||
|
||||
acceptExport("HC");
|
||||
markPaid("HC");
|
||||
pollAllocations("HC", SHAPES.HC.wagons);
|
||||
});
|
||||
|
||||
it("the train rides B + C at 35 of 54 — not full", () => {
|
||||
markPaid("HB");
|
||||
pollAllocations("HB", SHAPES.HB.wagons);
|
||||
withExportScheduleAt(DEPARTURE, (s) =>
|
||||
db<{ n: string }>(
|
||||
`SELECT count(DISTINCT wba.train_set_wagon_id) AS n
|
||||
FROM freight.wagon_booking_allocations wba
|
||||
JOIN freight.train_schedule_bookings tsb
|
||||
ON tsb.booking_id = wba.booking_id AND tsb.train_schedule_id = $1
|
||||
WHERE wba.deleted_at IS NULL AND tsb.deleted_at IS NULL`,
|
||||
[s.id],
|
||||
).then(({ rows }) =>
|
||||
expect(Number(rows[0].n), "B 20 + C 15 = 35").to.eq(
|
||||
SHAPES.HB.wagons + SHAPES.HC.wagons,
|
||||
),
|
||||
),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S18 — bigger than any train
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G3·S18: a booking larger than the train is refused outright", { retries: 0 }, () => {
|
||||
const DEPARTURE = departureAt(26);
|
||||
const BOOKING_DAY = eatDayStr(DEPARTURE);
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
(["OA", "OB1", "OB2"] as const).forEach(seedExportContract);
|
||||
});
|
||||
|
||||
it("operations schedules an empty export train", () => {
|
||||
ensureExportRoute();
|
||||
resetCorridorDay(DEPARTURE, EXP_DEST, EXP_ORIGIN);
|
||||
createImportSchedule({
|
||||
departure: DEPARTURE,
|
||||
locoPair: ["LOCO-EXP-7", "LOCO-EXP-8"],
|
||||
originCode: EXP_ORIGIN,
|
||||
destCode: EXP_DEST,
|
||||
});
|
||||
});
|
||||
|
||||
it("a 60-wagon booking fits NO train, even an empty one", () => {
|
||||
bookContainers({
|
||||
suffix: "OA",
|
||||
runStamp: stamp,
|
||||
isoSeed: 15_600,
|
||||
forty: 60,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
withBooking("OA", (b) =>
|
||||
readExportTrains(b.id, BOOKING_DAY).then((trains) => {
|
||||
// Every train on the day reports fits=false — the booking is simply
|
||||
// larger than the rolling stock, and export cannot divide it.
|
||||
trains.forEach((t) =>
|
||||
expect(t.fits, `${t.trainNumber ?? t.scheduleId} cannot take 60 wagons`).to.eq(false),
|
||||
);
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it("requesting the day is refused with a message sized to the real capacity", () => {
|
||||
// The refusal happens at requestOperation, carrying the largest workable
|
||||
// size so the customer knows what to rebook (booking-batch.service.ts:900).
|
||||
bookContainers({
|
||||
suffix: "OA",
|
||||
runStamp: stamp,
|
||||
isoSeed: 15_700,
|
||||
forty: 60,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
expectFailure: /whole|space|capacity/i,
|
||||
});
|
||||
});
|
||||
|
||||
it("split into two 30-wagon bookings, both board — the documented workaround", () => {
|
||||
(["OB1", "OB2"] as const).forEach((suffix, i) => {
|
||||
bookContainers({
|
||||
suffix,
|
||||
runStamp: stamp,
|
||||
isoSeed: 15_800 + i * 100,
|
||||
forty: 27,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
acceptExport(suffix);
|
||||
markPaid(suffix);
|
||||
pollAllocations(suffix, 27);
|
||||
});
|
||||
withExportScheduleAt(DEPARTURE, (s) =>
|
||||
db<{ n: string }>(
|
||||
`SELECT count(DISTINCT wba.train_set_wagon_id) AS n
|
||||
FROM freight.wagon_booking_allocations wba
|
||||
JOIN freight.train_schedule_bookings tsb
|
||||
ON tsb.booking_id = wba.booking_id AND tsb.train_schedule_id = $1
|
||||
WHERE wba.deleted_at IS NULL AND tsb.deleted_at IS NULL`,
|
||||
[s.id],
|
||||
).then(({ rows }) =>
|
||||
expect(Number(rows[0].n), "two 27-wagon bookings fill the train").to.eq(54),
|
||||
),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
export {};
|
||||
327
e2e/freight/cypress/e2e/flows/g4_multi_schedule.cy.ts
Normal file
327
e2e/freight/cypress/e2e/flows/g4_multi_schedule.cy.ts
Normal file
@@ -0,0 +1,327 @@
|
||||
/**
|
||||
* GROUP 4 · S19–S21 — two trains on one import day.
|
||||
*
|
||||
* The import batch fills a route-DAY, not a single schedule: `topUpFill`
|
||||
* re-runs the whole day pool (booking-batch.service.ts:2277, and see the
|
||||
* comment at :2284 explaining why a schedule-scoped query was the bug). So a
|
||||
* day with two departures is one pool with two boards, and these scenarios
|
||||
* pin down how demand lands across them.
|
||||
*
|
||||
* S19 an oversized booking is split ACROSS the two trains (import may do
|
||||
* what export cannot — see Group 3)
|
||||
* S20 the batch prefers whole placements over forcing a split when a second
|
||||
* train exists
|
||||
* S21 the fill-first-train policy: T1 is closed out with a split before T2
|
||||
* is opened up
|
||||
*
|
||||
* ── S20 vs S21 ARE COMPETING POLICIES ──────────────────────────────────────
|
||||
*
|
||||
* The original scenario document poses them as alternatives and says "pick
|
||||
* one, the test asserts it". They cannot both be true of the same engine:
|
||||
* S20 says a 10-wagon booking facing a 3-wagon gap on T1 goes WHOLE to T2;
|
||||
* S21 says the same booking is split 3 + 7 to close T1 first.
|
||||
*
|
||||
* The engine's actual rule is visible in the batch loop: a booking is placed
|
||||
* whole when ANY open train can take it whole, and `maybeOfferPartial` is
|
||||
* reached only when `!target` — i.e. when NO train fits it
|
||||
* (booking-batch.service.ts:2473-2496). That is S20. S21's fill-first policy
|
||||
* is therefore NOT implemented, and its test is written `.skip` documenting
|
||||
* the difference rather than asserting a behaviour that does not exist.
|
||||
*
|
||||
* Both trains are 53-wagon built consists (TRN-G1-1, TRN-G1-2) so the two
|
||||
* boards are directly comparable.
|
||||
*
|
||||
* Sequential steps per scenario — retries off.
|
||||
*/
|
||||
|
||||
import {
|
||||
acceptOperation,
|
||||
bookContainers,
|
||||
db,
|
||||
departureAt,
|
||||
eatDayStr,
|
||||
endPaymentPhase,
|
||||
ensureCorridorRoute,
|
||||
markPaid,
|
||||
pollAllocations,
|
||||
pollBookingStatus,
|
||||
resetCorridorDay,
|
||||
seedImportContract,
|
||||
setPriority,
|
||||
withBooking,
|
||||
withSchedule,
|
||||
} from "./import-utils";
|
||||
import {
|
||||
G1_TRAIN_2,
|
||||
G1_WAGONS,
|
||||
closeWindowAndRunBatch,
|
||||
configureAndOpenSchedule,
|
||||
expectVerdict,
|
||||
wagonsFor,
|
||||
} from "./g1-utils";
|
||||
|
||||
const stamp = String(Date.now());
|
||||
const stampedRef = (suffix: string) => `CTR-IMP-${stamp}-${suffix}`;
|
||||
|
||||
/**
|
||||
* Wagons allocated to one booking on one specific schedule.
|
||||
*
|
||||
* The schedule → consist link is `train_schedules.train_set_id` (a schedule
|
||||
* points AT its set; `train_sets` has no back-reference), so every query here
|
||||
* joins in that direction.
|
||||
*/
|
||||
function wagonsOnSchedule(suffix: string, scheduleId: string) {
|
||||
return db<{ n: string }>(
|
||||
`SELECT count(DISTINCT wba.train_set_wagon_id) AS n
|
||||
FROM freight.wagon_booking_allocations wba
|
||||
JOIN freight.bookings b ON b.id = wba.booking_id
|
||||
JOIN freight.contracts ct ON ct.id = b.contract_id
|
||||
JOIN freight.train_set_wagons tsw ON tsw.id = wba.train_set_wagon_id
|
||||
JOIN freight.train_schedules ts ON ts.train_set_id = tsw.train_set_id
|
||||
WHERE ct.reference LIKE 'CTR-IMP-%-' || $1
|
||||
AND ts.id = $2
|
||||
AND wba.deleted_at IS NULL AND b.deleted_at IS NULL
|
||||
AND ts.deleted_at IS NULL`,
|
||||
[suffix, scheduleId],
|
||||
).then(({ rows }) => Number(rows[0].n));
|
||||
}
|
||||
|
||||
/** Distinct schedules a booking's wagons sit on — >1 means it spans trains. */
|
||||
function schedulesFor(suffix: string) {
|
||||
return db<{ id: string }>(
|
||||
`SELECT DISTINCT ts.id
|
||||
FROM freight.wagon_booking_allocations wba
|
||||
JOIN freight.bookings b ON b.id = wba.booking_id
|
||||
JOIN freight.contracts ct ON ct.id = b.contract_id
|
||||
JOIN freight.train_set_wagons tsw ON tsw.id = wba.train_set_wagon_id
|
||||
JOIN freight.train_schedules ts ON ts.train_set_id = tsw.train_set_id
|
||||
WHERE ct.reference LIKE 'CTR-IMP-%-' || $1
|
||||
AND wba.deleted_at IS NULL AND b.deleted_at IS NULL
|
||||
AND ts.deleted_at IS NULL`,
|
||||
[suffix],
|
||||
).then(({ rows }) => rows.map((r) => r.id));
|
||||
}
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S19 — an oversized import booking spans both trains
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G4·S19: an import booking splits across two trains", { retries: 0 }, () => {
|
||||
const T1 = departureAt(31);
|
||||
const T2 = new Date(T1.getTime() + 3 * 3_600_000);
|
||||
const BOOKING_DAY = eatDayStr(T1);
|
||||
const SHAPES = {
|
||||
MA: { forty: 60, wagons: 60 },
|
||||
MB: { forty: 10, wagons: 10 },
|
||||
MC: { forty: 5, wagons: 5 },
|
||||
} as const;
|
||||
const ORDER = ["MA", "MB", "MC"] as const;
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g1-train.sql");
|
||||
ORDER.forEach((suffix) =>
|
||||
seedImportContract({ suffix, reference: stampedRef(suffix) }),
|
||||
);
|
||||
});
|
||||
|
||||
it("MA is bigger than either train but fits the day's combined capacity", () => {
|
||||
expect(SHAPES.MA.wagons, "60 > one train").to.be.greaterThan(G1_WAGONS);
|
||||
expect(SHAPES.MA.wagons, "60 < two trains").to.be.lessThan(G1_WAGONS * 2);
|
||||
expect(eatDayStr(T2), "both trains run the same EAT day").to.eq(BOOKING_DAY);
|
||||
});
|
||||
|
||||
it("the day runs two 53-wagon built trains", () => {
|
||||
ensureCorridorRoute();
|
||||
resetCorridorDay(T1);
|
||||
resetCorridorDay(T2);
|
||||
configureAndOpenSchedule({ departure: T1 });
|
||||
configureAndOpenSchedule({ departure: T2, trainCode: G1_TRAIN_2 });
|
||||
});
|
||||
|
||||
it("three bookings arrive, MA first in priority", () => {
|
||||
let isoSeed = 17_100;
|
||||
ORDER.forEach((suffix) => {
|
||||
bookContainers({
|
||||
suffix,
|
||||
runStamp: stamp,
|
||||
isoSeed,
|
||||
forty: SHAPES[suffix].forty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
isoSeed += SHAPES[suffix].forty;
|
||||
acceptOperation(suffix);
|
||||
});
|
||||
ORDER.forEach((suffix, i) => setPriority(suffix, i + 1));
|
||||
});
|
||||
|
||||
it("MA is placed across BOTH trains — import may span, unlike export", () => {
|
||||
closeWindowAndRunBatch(T1);
|
||||
ORDER.forEach((suffix) =>
|
||||
pollBookingStatus(suffix, ["SELECTED_FOR_BATCH", "AWAITING_PAYMENT"]),
|
||||
);
|
||||
ORDER.forEach((suffix) => markPaid(suffix));
|
||||
ORDER.forEach((suffix) => pollAllocations(suffix, 1));
|
||||
|
||||
// The distinguishing assertion: MA's wagons sit on two different schedules.
|
||||
schedulesFor("MA").then((ids) => {
|
||||
expect(ids.length, "MA spans two trains").to.eq(2);
|
||||
});
|
||||
withSchedule(T1, (s1) =>
|
||||
wagonsOnSchedule("MA", s1.id).then((n) =>
|
||||
expect(n, "MA fills T1 completely").to.eq(G1_WAGONS),
|
||||
),
|
||||
);
|
||||
});
|
||||
|
||||
it("T1 departs FULL with MA alone; T2 carries the remainder plus MB and MC", () => {
|
||||
withSchedule(T1, (s) => endPaymentPhase(s.id));
|
||||
expectVerdict(T1, { wagons: G1_WAGONS, full: true });
|
||||
|
||||
// MA's overflow (7) + MB (10) + MC (5) = 22 on the second train.
|
||||
const overflow = SHAPES.MA.wagons - G1_WAGONS; // 7
|
||||
const onT2 = overflow + SHAPES.MB.wagons + SHAPES.MC.wagons; // 22
|
||||
expect(onT2, "22 wagons on T2").to.eq(22);
|
||||
expectVerdict(T2, { wagons: onT2, full: false });
|
||||
});
|
||||
});
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S20 — whole placements are preferred while a second train has room
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G4·S20: the batch prefers a whole placement over a forced split", { retries: 0 }, () => {
|
||||
const T1 = departureAt(32);
|
||||
const T2 = new Date(T1.getTime() + 3 * 3_600_000);
|
||||
const BOOKING_DAY = eatDayStr(T1);
|
||||
const SHAPES = {
|
||||
WA: { forty: 30, wagons: 30 },
|
||||
WB: { forty: 30, wagons: 30 },
|
||||
WC: { forty: 20, wagons: 20 },
|
||||
WD: { forty: 10, wagons: 10 },
|
||||
} as const;
|
||||
const ORDER = ["WA", "WB", "WC", "WD"] as const;
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g1-train.sql");
|
||||
ORDER.forEach((suffix) =>
|
||||
seedImportContract({ suffix, reference: stampedRef(suffix) }),
|
||||
);
|
||||
});
|
||||
|
||||
it("90 wagons of demand across two 53-wagon trains", () => {
|
||||
ORDER.forEach((s) =>
|
||||
expect(wagonsFor(0, SHAPES[s].forty), `${s} wagons`).to.eq(SHAPES[s].wagons),
|
||||
);
|
||||
expect(
|
||||
ORDER.reduce((sum, s) => sum + SHAPES[s].wagons, 0),
|
||||
"90 wagons of demand",
|
||||
).to.eq(90);
|
||||
});
|
||||
|
||||
it("both trains run and all four book", () => {
|
||||
ensureCorridorRoute();
|
||||
resetCorridorDay(T1);
|
||||
resetCorridorDay(T2);
|
||||
configureAndOpenSchedule({ departure: T1 });
|
||||
configureAndOpenSchedule({ departure: T2, trainCode: G1_TRAIN_2 });
|
||||
|
||||
let isoSeed = 17_600;
|
||||
ORDER.forEach((suffix) => {
|
||||
bookContainers({
|
||||
suffix,
|
||||
runStamp: stamp,
|
||||
isoSeed,
|
||||
forty: SHAPES[suffix].forty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
isoSeed += SHAPES[suffix].forty;
|
||||
acceptOperation(suffix);
|
||||
});
|
||||
ORDER.forEach((suffix, i) => setPriority(suffix, i + 1));
|
||||
closeWindowAndRunBatch(T1);
|
||||
});
|
||||
|
||||
it("EVERY booking is placed WHOLE — none is split to close T1's gap", () => {
|
||||
ORDER.forEach((suffix) =>
|
||||
pollBookingStatus(suffix, ["SELECTED_FOR_BATCH", "AWAITING_PAYMENT"]),
|
||||
);
|
||||
ORDER.forEach((suffix) => markPaid(suffix));
|
||||
ORDER.forEach((suffix) => pollAllocations(suffix, SHAPES[suffix].wagons));
|
||||
|
||||
// The policy assertion: with a second train available, `maybeOfferPartial`
|
||||
// is never reached, because a whole placement always exists.
|
||||
ORDER.forEach((suffix) => {
|
||||
withBooking(suffix, (b) =>
|
||||
expect(b.is_split, `${suffix} placed whole`).to.eq(false),
|
||||
);
|
||||
schedulesFor(suffix).then((ids) =>
|
||||
expect(ids.length, `${suffix} rides ONE train`).to.eq(1),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
it("neither train ends FULL — whole placements leave gaps, and that is correct", () => {
|
||||
withSchedule(T1, (s) => endPaymentPhase(s.id));
|
||||
withSchedule(T2, (s) => endPaymentPhase(s.id));
|
||||
|
||||
// 90 wagons over two 53-slot trains cannot both be full; the engine
|
||||
// trades slot efficiency for keeping bookings intact.
|
||||
withSchedule(T1, (s1) =>
|
||||
db<{ n: string }>(
|
||||
`SELECT count(DISTINCT wba.train_set_wagon_id) AS n
|
||||
FROM freight.wagon_booking_allocations wba
|
||||
JOIN freight.train_schedule_bookings tsb
|
||||
ON tsb.booking_id = wba.booking_id AND tsb.train_schedule_id = $1
|
||||
WHERE wba.deleted_at IS NULL AND tsb.deleted_at IS NULL`,
|
||||
[s1.id],
|
||||
).then(({ rows }) => {
|
||||
const onT1 = Number(rows[0].n);
|
||||
expect(onT1, "T1 carries whole bookings only").to.be.at.most(G1_WAGONS);
|
||||
// Whatever landed on T1, the day's total is all 90 wagons.
|
||||
withSchedule(T2, (s2) =>
|
||||
db<{ n: string }>(
|
||||
`SELECT count(DISTINCT wba.train_set_wagon_id) AS n
|
||||
FROM freight.wagon_booking_allocations wba
|
||||
JOIN freight.train_schedule_bookings tsb
|
||||
ON tsb.booking_id = wba.booking_id AND tsb.train_schedule_id = $1
|
||||
WHERE wba.deleted_at IS NULL AND tsb.deleted_at IS NULL`,
|
||||
[s2.id],
|
||||
).then(({ rows: r2 }) =>
|
||||
expect(onT1 + Number(r2[0].n), "all 90 wagons placed across the day").to.eq(90),
|
||||
),
|
||||
);
|
||||
}),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S21 — the competing "fill T1 first" policy (NOT implemented)
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G4·S21: fill-first-train policy", { retries: 0 }, () => {
|
||||
it("documents that the engine prefers whole placement, not fill-first", () => {
|
||||
// S20 (above) asserts the implemented behaviour. Keeping this as a live,
|
||||
// passing note rather than a skipped mystery: the two scenarios are
|
||||
// mutually exclusive and S20 is the one that matches the code.
|
||||
cy.log(
|
||||
"S21 proposes closing T1 with a split before opening T2. The batch " +
|
||||
"instead reaches maybeOfferPartial only when NO train fits the " +
|
||||
"booking whole (booking-batch.service.ts:2473-2496), so a second " +
|
||||
"train with room always wins. S20 is the asserted policy.",
|
||||
);
|
||||
});
|
||||
|
||||
// Un-skip only if the fill-first policy is deliberately implemented; it
|
||||
// would change S19 and S20's outcomes too, so treat it as a product change
|
||||
// rather than a test fix.
|
||||
it.skip("closes T1 with a split before opening T2", () => {
|
||||
// Would assert: A30 + B20 + C-split(3) fills T1 to 53/53, and C's
|
||||
// remaining 7 wagons roll to T2 — i.e. a split is CHOSEN even though a
|
||||
// whole placement was available on T2.
|
||||
});
|
||||
});
|
||||
|
||||
export {};
|
||||
377
e2e/freight/cypress/e2e/flows/g5_waitlist.cy.ts
Normal file
377
e2e/freight/cypress/e2e/flows/g5_waitlist.cy.ts
Normal file
@@ -0,0 +1,377 @@
|
||||
/**
|
||||
* GROUP 5 · S22–S24 — what happens to a booking that loses its seat.
|
||||
*
|
||||
* S22 an expired booking moves itself to the next day, no re-approval and
|
||||
* no re-pricing
|
||||
* S23 a booking that paid a SPLIT keeps the paid part when the REMAINDER
|
||||
* later expires — the two halves have independent fates
|
||||
* S24 the waiting list is walked in priority order when freed space is too
|
||||
* small for its head
|
||||
*
|
||||
* These are the recovery paths. Group 1 proved the batch fills correctly; this
|
||||
* group proves that losing is survivable — a customer whose reservation lapses
|
||||
* still owns their cargo, their contract, and their place in line.
|
||||
*
|
||||
* Sequential steps per scenario — retries off.
|
||||
*/
|
||||
|
||||
import {
|
||||
acceptOperation,
|
||||
bookContainers,
|
||||
db,
|
||||
departureAt,
|
||||
eatDayStr,
|
||||
endPaymentPhase,
|
||||
ensureCorridorRoute,
|
||||
forceReservationExpiry,
|
||||
markPaid,
|
||||
pollAllocations,
|
||||
pollBookingStatus,
|
||||
resetCorridorDay,
|
||||
seedImportContract,
|
||||
setPriority,
|
||||
settleViaGateway,
|
||||
withBooking,
|
||||
withSchedule,
|
||||
} from "./import-utils";
|
||||
import {
|
||||
G1_TRAIN_2,
|
||||
G1_WAGONS,
|
||||
closeWindowAndRunBatch,
|
||||
configureAndOpenSchedule,
|
||||
expectBoard,
|
||||
expectPromoted,
|
||||
expectRecoverable,
|
||||
expectSplitOffer,
|
||||
expectVerdict,
|
||||
expectWaitlisted,
|
||||
} from "./g1-utils";
|
||||
|
||||
const stamp = String(Date.now());
|
||||
const stampedRef = (suffix: string) => `CTR-IMP-${stamp}-${suffix}`;
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S22 — an expired booking rebooks the next day at the same price
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G5·S22: an expired booking moves to the next day intact", { retries: 0 }, () => {
|
||||
const DAY_1 = departureAt(33);
|
||||
const DAY_2 = departureAt(34);
|
||||
const BOOKING_DAY_1 = eatDayStr(DAY_1);
|
||||
const BOOKING_DAY_2 = eatDayStr(DAY_2);
|
||||
const SHAPES = {
|
||||
RA: { forty: 20, wagons: 20 },
|
||||
RB: { forty: 20, wagons: 20 },
|
||||
RC: { forty: 13, wagons: 13 },
|
||||
} as const;
|
||||
const ORDER = ["RA", "RB", "RC"] as const;
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g1-train.sql");
|
||||
ORDER.forEach((suffix) =>
|
||||
seedImportContract({ suffix, reference: stampedRef(suffix) }),
|
||||
);
|
||||
});
|
||||
|
||||
it("day 1's train fills with RA, RB and RC", () => {
|
||||
ensureCorridorRoute();
|
||||
resetCorridorDay(DAY_1);
|
||||
configureAndOpenSchedule({ departure: DAY_1 });
|
||||
|
||||
let isoSeed = 18_100;
|
||||
ORDER.forEach((suffix) => {
|
||||
bookContainers({
|
||||
suffix,
|
||||
runStamp: stamp,
|
||||
isoSeed,
|
||||
forty: SHAPES[suffix].forty,
|
||||
scheduledDate: BOOKING_DAY_1,
|
||||
});
|
||||
isoSeed += SHAPES[suffix].forty;
|
||||
acceptOperation(suffix);
|
||||
});
|
||||
ORDER.forEach((suffix, i) => setPriority(suffix, i + 1));
|
||||
closeWindowAndRunBatch(DAY_1);
|
||||
ORDER.forEach((suffix) =>
|
||||
pollBookingStatus(suffix, ["SELECTED_FOR_BATCH", "AWAITING_PAYMENT"]),
|
||||
);
|
||||
});
|
||||
|
||||
it("RC never pays and expires — day 1 departs at 40/53", () => {
|
||||
(["RA", "RB"] as const).forEach((suffix) => {
|
||||
markPaid(suffix);
|
||||
pollAllocations(suffix, SHAPES[suffix].wagons);
|
||||
});
|
||||
forceReservationExpiry("RC");
|
||||
withSchedule(DAY_1, (s) => endPaymentPhase(s.id));
|
||||
|
||||
const riding = SHAPES.RA.wagons + SHAPES.RB.wagons; // 40
|
||||
expectVerdict(DAY_1, { wagons: riding, full: false });
|
||||
// The seat is genuinely released, not held by the dead reservation.
|
||||
expectBoard(DAY_1, { expired: 1, capacity: { used: riding, full: false } });
|
||||
});
|
||||
|
||||
it("RC's contract survives the expiry — no re-approval needed", () => {
|
||||
expectRecoverable("RC");
|
||||
});
|
||||
|
||||
it("RC rebooks day 2 directly, with no staff approval step in between", () => {
|
||||
resetCorridorDay(DAY_2);
|
||||
configureAndOpenSchedule({ departure: DAY_2, trainCode: G1_TRAIN_2 });
|
||||
|
||||
// The same customer, the same contract, a new day — straight back into
|
||||
// OPERATION_REQUEST_PENDING as if nothing had gone wrong.
|
||||
bookContainers({
|
||||
suffix: "RC",
|
||||
runStamp: stamp,
|
||||
isoSeed: 18_400,
|
||||
forty: SHAPES.RC.forty,
|
||||
scheduledDate: BOOKING_DAY_2,
|
||||
});
|
||||
pollBookingStatus("RC", "OPERATION_REQUEST_PENDING", 10);
|
||||
acceptOperation("RC");
|
||||
});
|
||||
|
||||
it("day 2 carries RC plus a new 40-wagon customer — FULL at 53/53", () => {
|
||||
seedImportContract({ suffix: "RD", reference: stampedRef("RD") });
|
||||
bookContainers({
|
||||
suffix: "RD",
|
||||
runStamp: stamp,
|
||||
isoSeed: 18_500,
|
||||
forty: 40,
|
||||
scheduledDate: BOOKING_DAY_2,
|
||||
});
|
||||
acceptOperation("RD");
|
||||
|
||||
closeWindowAndRunBatch(DAY_2);
|
||||
(["RC", "RD"] as const).forEach((suffix) => {
|
||||
pollBookingStatus(suffix, ["SELECTED_FOR_BATCH", "AWAITING_PAYMENT"]);
|
||||
markPaid(suffix);
|
||||
});
|
||||
pollAllocations("RC", SHAPES.RC.wagons);
|
||||
pollAllocations("RD", 40);
|
||||
|
||||
withSchedule(DAY_2, (s) => endPaymentPhase(s.id));
|
||||
expectVerdict(DAY_2, { wagons: G1_WAGONS, full: true });
|
||||
});
|
||||
});
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S23 — the paid half of a split is never clawed back
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G5·S23: a split's paid part survives the remainder expiring", { retries: 0 }, () => {
|
||||
const DAY_1 = departureAt(35);
|
||||
const DAY_2 = departureAt(36);
|
||||
const BOOKING_DAY_1 = eatDayStr(DAY_1);
|
||||
const BOOKING_DAY_2 = eatDayStr(DAY_2);
|
||||
const SHAPES = {
|
||||
SA: { forty: 30, wagons: 30 },
|
||||
SB: { twenty: 40, wagons: 20 },
|
||||
/** Wants 10 wagons, will be offered the last 3. */
|
||||
SC: { twenty: 20, wagons: 10 },
|
||||
} as const;
|
||||
const GAP = G1_WAGONS - SHAPES.SA.wagons - SHAPES.SB.wagons; // 3
|
||||
const OFFERED_CONTAINERS = GAP * 2; // 6
|
||||
const REMAINDER_CONTAINERS = SHAPES.SC.twenty - OFFERED_CONTAINERS; // 14
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g1-train.sql");
|
||||
(["SA", "SB", "SC"] as const).forEach((suffix) =>
|
||||
seedImportContract({ suffix, reference: stampedRef(suffix) }),
|
||||
);
|
||||
});
|
||||
|
||||
it("SC pays a 3-wagon split on day 1 and rides", () => {
|
||||
ensureCorridorRoute();
|
||||
resetCorridorDay(DAY_1);
|
||||
configureAndOpenSchedule({ departure: DAY_1 });
|
||||
|
||||
bookContainers({
|
||||
suffix: "SA",
|
||||
runStamp: stamp,
|
||||
isoSeed: 18_800,
|
||||
forty: SHAPES.SA.forty,
|
||||
scheduledDate: BOOKING_DAY_1,
|
||||
});
|
||||
acceptOperation("SA");
|
||||
bookContainers({
|
||||
suffix: "SB",
|
||||
runStamp: stamp,
|
||||
isoSeed: 18_900,
|
||||
twenty: SHAPES.SB.twenty,
|
||||
scheduledDate: BOOKING_DAY_1,
|
||||
});
|
||||
acceptOperation("SB");
|
||||
bookContainers({
|
||||
suffix: "SC",
|
||||
runStamp: stamp,
|
||||
isoSeed: 19_000,
|
||||
twenty: SHAPES.SC.twenty,
|
||||
scheduledDate: BOOKING_DAY_1,
|
||||
});
|
||||
acceptOperation("SC");
|
||||
(["SA", "SB", "SC"] as const).forEach((suffix, i) => setPriority(suffix, i + 1));
|
||||
|
||||
closeWindowAndRunBatch(DAY_1);
|
||||
expectSplitOffer("SC");
|
||||
|
||||
markPaid("SA");
|
||||
pollAllocations("SA", SHAPES.SA.wagons);
|
||||
markPaid("SB");
|
||||
pollAllocations("SB", SHAPES.SB.wagons);
|
||||
// Only the gateway settle path applies a pending offer.
|
||||
settleViaGateway("SC");
|
||||
pollAllocations("SC", GAP);
|
||||
|
||||
withSchedule(DAY_1, (s) => endPaymentPhase(s.id));
|
||||
expectVerdict(DAY_1, { wagons: G1_WAGONS, full: true });
|
||||
});
|
||||
|
||||
it("the remainder is rebooked onto day 2 and then IGNORED", () => {
|
||||
resetCorridorDay(DAY_2);
|
||||
configureAndOpenSchedule({ departure: DAY_2, trainCode: G1_TRAIN_2 });
|
||||
|
||||
// A split customer must rebook EXACTLY the outstanding remainder.
|
||||
bookContainers({
|
||||
suffix: "SC",
|
||||
runStamp: stamp,
|
||||
isoSeed: 19_200,
|
||||
twenty: REMAINDER_CONTAINERS,
|
||||
scheduledDate: BOOKING_DAY_2,
|
||||
});
|
||||
pollBookingStatus("SC", "OPERATION_REQUEST_PENDING", 10);
|
||||
acceptOperation("SC");
|
||||
closeWindowAndRunBatch(DAY_2);
|
||||
pollBookingStatus("SC", ["SELECTED_FOR_BATCH", "AWAITING_PAYMENT"]);
|
||||
|
||||
// …and this time the customer lets it lapse.
|
||||
forceReservationExpiry("SC");
|
||||
});
|
||||
|
||||
it("ONLY the remainder expired — the paid 3 wagons still ride day 1", () => {
|
||||
// The newest SC booking (the remainder) is the expired one.
|
||||
withBooking("SC", (b) => expect(b.status, "remainder expired").to.eq("EXPIRED"));
|
||||
|
||||
// The paid part is a SEPARATE booking row on day 1, untouched. Losing it
|
||||
// here would mean clawing back cargo the customer already paid to ship.
|
||||
withSchedule(DAY_1, (s) =>
|
||||
db<{ n: string; status: string }>(
|
||||
`SELECT count(*) AS n, max(b.status) AS status
|
||||
FROM freight.bookings b
|
||||
JOIN freight.contracts ct ON ct.id = b.contract_id
|
||||
JOIN freight.train_schedule_bookings tsb
|
||||
ON tsb.booking_id = b.id AND tsb.train_schedule_id = $2
|
||||
WHERE ct.reference LIKE 'CTR-IMP-%-' || $1
|
||||
AND b.deleted_at IS NULL AND tsb.deleted_at IS NULL`,
|
||||
["SC", s.id],
|
||||
).then(({ rows }) => {
|
||||
expect(Number(rows[0].n), "the paid split still holds its seat").to.eq(1);
|
||||
expect(rows[0].status, "and is still PAID").to.eq("PAID");
|
||||
}),
|
||||
);
|
||||
|
||||
// Day 1 is unchanged by the day-2 expiry.
|
||||
expectVerdict(DAY_1, { wagons: G1_WAGONS, full: true });
|
||||
});
|
||||
});
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S24 — freed space smaller than the waiting list's head
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G5·S24: the waiting list is walked, never skipped silently", { retries: 0 }, () => {
|
||||
const DEPARTURE = departureAt(37);
|
||||
const BOOKING_DAY = eatDayStr(DEPARTURE);
|
||||
const SHAPES = {
|
||||
QA: { forty: 10, wagons: 10 },
|
||||
QB: { forty: 43, wagons: 43 },
|
||||
/** Waiting list head — 15 wagons, more than QA's 10. */
|
||||
QD: { forty: 15, wagons: 15 },
|
||||
/** Behind it — 8 wagons, which DOES fit. */
|
||||
QE: { forty: 8, wagons: 8 },
|
||||
} as const;
|
||||
const ORDER = ["QA", "QB", "QD", "QE"] as const;
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g1-train.sql");
|
||||
ORDER.forEach((suffix) =>
|
||||
seedImportContract({ suffix, reference: stampedRef(suffix) }),
|
||||
);
|
||||
});
|
||||
|
||||
it("the train fills; QD and QE queue behind it in priority order", () => {
|
||||
expect(SHAPES.QA.wagons + SHAPES.QB.wagons, "53/53").to.eq(G1_WAGONS);
|
||||
expect(SHAPES.QD.wagons, "QD is bigger than the space QA will free").to.be.greaterThan(
|
||||
SHAPES.QA.wagons,
|
||||
);
|
||||
expect(SHAPES.QE.wagons, "QE fits inside it").to.be.at.most(SHAPES.QA.wagons);
|
||||
|
||||
ensureCorridorRoute();
|
||||
resetCorridorDay(DEPARTURE);
|
||||
configureAndOpenSchedule({ departure: DEPARTURE });
|
||||
|
||||
let isoSeed = 19_500;
|
||||
ORDER.forEach((suffix) => {
|
||||
bookContainers({
|
||||
suffix,
|
||||
runStamp: stamp,
|
||||
isoSeed,
|
||||
forty: SHAPES[suffix].forty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
isoSeed += SHAPES[suffix].forty;
|
||||
acceptOperation(suffix);
|
||||
});
|
||||
ORDER.forEach((suffix, i) => setPriority(suffix, i + 1));
|
||||
|
||||
closeWindowAndRunBatch(DEPARTURE);
|
||||
(["QA", "QB"] as const).forEach((suffix) =>
|
||||
pollBookingStatus(suffix, ["SELECTED_FOR_BATCH", "AWAITING_PAYMENT"]),
|
||||
);
|
||||
(["QD", "QE"] as const).forEach((suffix) => expectWaitlisted(suffix));
|
||||
});
|
||||
|
||||
it("QA expires, freeing 10 — too few for QD, so the list is walked to QE", () => {
|
||||
markPaid("QB");
|
||||
pollAllocations("QB", SHAPES.QB.wagons);
|
||||
forceReservationExpiry("QA");
|
||||
|
||||
// QD is the head of the list but needs 15 of the 10 available. The engine
|
||||
// must not stop there: it walks on and promotes QE, which fits.
|
||||
expectPromoted("QE");
|
||||
markPaid("QE");
|
||||
pollAllocations("QE", SHAPES.QE.wagons);
|
||||
});
|
||||
|
||||
it("QD is NOT silently dropped — it keeps its place in line", () => {
|
||||
// The failure this guards against is a waiting list that discards whoever
|
||||
// it could not seat. QD must still be waiting, with its cargo intact.
|
||||
expectWaitlisted("QD");
|
||||
withBooking("QD", (b) => {
|
||||
expect(b.is_split, "QD was not quietly reduced").to.eq(false);
|
||||
db<{ q: string }>(
|
||||
`SELECT sum(quantity) AS q FROM freight.booking_container
|
||||
WHERE booking_id = $1 AND deleted_at IS NULL`,
|
||||
[b.id],
|
||||
).then(({ rows }) =>
|
||||
expect(Number(rows[0].q), "QD's 15 containers intact").to.eq(SHAPES.QD.forty),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
it("the train departs at 51/53 — two wagons unsold because QD would not fit", () => {
|
||||
withSchedule(DEPARTURE, (s) => endPaymentPhase(s.id));
|
||||
const riding = SHAPES.QB.wagons + SHAPES.QE.wagons; // 51
|
||||
expectVerdict(DEPARTURE, { wagons: riding, full: false });
|
||||
expectBoard(DEPARTURE, {
|
||||
expired: 1,
|
||||
capacity: { used: riding, full: false },
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
export {};
|
||||
554
e2e/freight/cypress/e2e/flows/g6_corridor.cy.ts
Normal file
554
e2e/freight/cypress/e2e/flows/g6_corridor.cy.ts
Normal file
@@ -0,0 +1,554 @@
|
||||
/**
|
||||
* GROUP 6 · S25–S29 — the train on the corridor.
|
||||
*
|
||||
* S25 three bookings alight at three different stations on one run
|
||||
* S26 mid-corridor (Ethiopia → Ethiopia) boarding — see the correction below
|
||||
* S27 tracking before the booking is on a schedule at all
|
||||
* S28 a booking ARRIVES while its train is still moving
|
||||
* S29 out-of-order checkpoints — see the correction below
|
||||
*
|
||||
* Corridor (6 stops, DJ → ET = IMPORT):
|
||||
* DJIB_PORT → NAGAD → DIRE_DAWA → E2E_AWASH → MOJO → KALITY
|
||||
* seq 0 1 2 3 4 5
|
||||
*
|
||||
* ── TWO SCENARIO CORRECTIONS (full write-up in SCENARIO_ENGINE_NOTES.md) ───
|
||||
*
|
||||
* S26 is INVERTED. The scenario expects a mid-corridor Ethiopian booking to be
|
||||
* rejected as disabled intercity. The engine does the opposite: DOMESTIC is a
|
||||
* first-class direction derived from the yards' countries
|
||||
* (bookings.service.ts:270), and the guard rejects *non*-Ethiopian endpoints —
|
||||
* 'Intercity bookings only run between Ethiopian yards' (:218). Per the
|
||||
* decision recorded in the notes, S26 is written to assert that intercity
|
||||
* WORKS, plus the two constraints that really do apply to it.
|
||||
*
|
||||
* S29 asserts a guard that DOES NOT EXIST. `recordCheckpoint`
|
||||
* (train-scheduling.service.ts:3681) validates only that the schedule exists,
|
||||
* is DISPATCHED, and that the station is on the route. Nothing compares
|
||||
* sequenceNo against the highest already logged, so "Arrived Adama" before
|
||||
* "Passed Meiso" is accepted. It is written below as a passing test of CURRENT
|
||||
* behaviour plus a skipped test of the DESIRED behaviour, because the gap has
|
||||
* teeth: the position fix at :3741 relocates the locomotives, every wagon on
|
||||
* the schedule, and the built train to the out-of-order station's yard.
|
||||
*
|
||||
* Sequential steps per scenario — retries off.
|
||||
*/
|
||||
|
||||
import {
|
||||
acceptOperation,
|
||||
apiPost,
|
||||
bookContainers,
|
||||
CORRIDOR,
|
||||
db,
|
||||
departureAt,
|
||||
DEST,
|
||||
eatDayStr,
|
||||
endPaymentPhase,
|
||||
ensureCorridorRoute,
|
||||
markPaid,
|
||||
opsStaff,
|
||||
ORIGIN,
|
||||
pollAllocations,
|
||||
pollBookingStatus,
|
||||
pollDb,
|
||||
recordCheckpoint,
|
||||
resetCorridorDay,
|
||||
seedImportContract,
|
||||
withBooking,
|
||||
withSchedule,
|
||||
type ScheduleRow,
|
||||
} from "./import-utils";
|
||||
import {
|
||||
closeWindowAndRunBatch,
|
||||
configureAndOpenSchedule,
|
||||
} from "./g1-utils";
|
||||
|
||||
const stamp = String(Date.now());
|
||||
const stampedRef = (suffix: string) => `CTR-IMP-${stamp}-${suffix}`;
|
||||
|
||||
/** Corridor positions, for readability in the checkpoint walks. */
|
||||
const SEQ = {
|
||||
DJIB_PORT: 0,
|
||||
NAGAD: 1,
|
||||
DIRE_DAWA: 2,
|
||||
E2E_AWASH: 3,
|
||||
MOJO: 4,
|
||||
KALITY: 5,
|
||||
} as const;
|
||||
|
||||
/** Point a booking's destination at a mid-corridor yard so it alights early. */
|
||||
function setDestination(suffix: string, yardCode: string) {
|
||||
db(
|
||||
`UPDATE freight.bookings b
|
||||
SET destination_yard_id = (SELECT id FROM freight.yards WHERE code = $2)
|
||||
FROM freight.contracts ct
|
||||
WHERE ct.id = b.contract_id
|
||||
AND ct.reference LIKE 'CTR-IMP-%-' || $1
|
||||
AND b.deleted_at IS NULL`,
|
||||
[suffix, yardCode],
|
||||
);
|
||||
}
|
||||
|
||||
function currentSequenceNo(scheduleId: string) {
|
||||
return db<{ seq: number | null }>(
|
||||
`SELECT max(sequence_no) AS seq FROM freight.train_checkpoint_events
|
||||
WHERE train_schedule_id = $1`,
|
||||
[scheduleId],
|
||||
).then(({ rows }) => Number(rows[0].seq ?? -1));
|
||||
}
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S25 — three alight points on one run
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G6·S25: three bookings alight at three stations", { retries: 0 }, () => {
|
||||
const DEPARTURE = departureAt(38);
|
||||
const BOOKING_DAY = eatDayStr(DEPARTURE);
|
||||
const SHAPES = {
|
||||
KA: { forty: 20, wagons: 20, alights: "DIRE_DAWA" },
|
||||
KB: { forty: 20, wagons: 20, alights: "MOJO" },
|
||||
KC: { forty: 13, wagons: 13, alights: "KALITY" },
|
||||
} as const;
|
||||
const ORDER = ["KA", "KB", "KC"] as const;
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g1-train.sql");
|
||||
ORDER.forEach((suffix) =>
|
||||
seedImportContract({ suffix, reference: stampedRef(suffix) }),
|
||||
);
|
||||
});
|
||||
|
||||
it("all three board at Djibouti Port, bound for three different stations", () => {
|
||||
ensureCorridorRoute();
|
||||
resetCorridorDay(DEPARTURE);
|
||||
configureAndOpenSchedule({ departure: DEPARTURE });
|
||||
|
||||
let isoSeed = 20_100;
|
||||
ORDER.forEach((suffix) => {
|
||||
bookContainers({
|
||||
suffix,
|
||||
runStamp: stamp,
|
||||
isoSeed,
|
||||
forty: SHAPES[suffix].forty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
isoSeed += SHAPES[suffix].forty;
|
||||
acceptOperation(suffix);
|
||||
});
|
||||
|
||||
closeWindowAndRunBatch(DEPARTURE);
|
||||
ORDER.forEach((suffix) => {
|
||||
markPaid(suffix);
|
||||
pollAllocations(suffix, SHAPES[suffix].wagons);
|
||||
});
|
||||
// Re-point the two early alighters now that allocation is done.
|
||||
setDestination("KA", SHAPES.KA.alights);
|
||||
setDestination("KB", SHAPES.KB.alights);
|
||||
withSchedule(DEPARTURE, (s) => endPaymentPhase(s.id));
|
||||
});
|
||||
|
||||
it("the train dispatches — every booking boards IN_TRANSIT", () => {
|
||||
withSchedule(DEPARTURE, (s) => {
|
||||
apiPost(opsStaff, `/api/train-scheduling/schedules/${s.id}/dispatch`)
|
||||
.its("status")
|
||||
.should("be.oneOf", [200, 201]);
|
||||
});
|
||||
ORDER.forEach((suffix) => pollBookingStatus(suffix, "IN_TRANSIT", 10));
|
||||
});
|
||||
|
||||
it("KA alights at Dire Dawa — the other two ride on", () => {
|
||||
withSchedule(DEPARTURE, (s) => {
|
||||
recordCheckpoint(s.id, SEQ.NAGAD, "PASSED");
|
||||
recordCheckpoint(s.id, SEQ.DIRE_DAWA, "PASSED");
|
||||
});
|
||||
// A checkpoint at an intermediate yard auto-unloads whatever was destined
|
||||
// there (booking-journey.service.ts:261 autoUnloadAtYard).
|
||||
pollBookingStatus("KA", "ARRIVED", 15);
|
||||
(["KB", "KC"] as const).forEach((suffix) =>
|
||||
withBooking(suffix, (b) =>
|
||||
expect(b.status, `${suffix} still riding`).to.eq("IN_TRANSIT"),
|
||||
),
|
||||
);
|
||||
});
|
||||
|
||||
it("KB alights at Mojo; KC rides to the terminal", () => {
|
||||
withSchedule(DEPARTURE, (s) => {
|
||||
recordCheckpoint(s.id, SEQ.E2E_AWASH, "PASSED");
|
||||
recordCheckpoint(s.id, SEQ.MOJO, "PASSED");
|
||||
});
|
||||
pollBookingStatus("KB", "ARRIVED", 15);
|
||||
withBooking("KC", (b) =>
|
||||
expect(b.status, "KC still riding to KALITY").to.eq("IN_TRANSIT"),
|
||||
);
|
||||
|
||||
withSchedule(DEPARTURE, (s) => recordCheckpoint(s.id, SEQ.KALITY, "ARRIVED"));
|
||||
pollBookingStatus("KC", "ARRIVED", 20);
|
||||
});
|
||||
|
||||
it("the corridor was walked in order and the train ends ARRIVED", () => {
|
||||
withSchedule(DEPARTURE, (s) => {
|
||||
pollDb<ScheduleRow>(
|
||||
"schedule ARRIVED",
|
||||
`SELECT status FROM freight.train_schedules WHERE id = $1`,
|
||||
[s.id],
|
||||
(row) => row?.status === "ARRIVED",
|
||||
20,
|
||||
);
|
||||
// currentSequenceNo advanced monotonically to the terminal.
|
||||
currentSequenceNo(s.id).then((seq) =>
|
||||
expect(seq, "reached the last stop").to.eq(SEQ.KALITY),
|
||||
);
|
||||
db<{ n: string }>(
|
||||
`SELECT count(*) AS n FROM freight.train_checkpoint_events
|
||||
WHERE train_schedule_id = $1`,
|
||||
[s.id],
|
||||
).then(({ rows }) =>
|
||||
// 5 logged here + the origin DEPARTED stamped by dispatch.
|
||||
expect(Number(rows[0].n), "one event per station reached").to.be.at.least(5),
|
||||
);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S26 — intercity WORKS (scenario corrected, see the header)
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G6·S26: mid-corridor intercity is supported, not blocked", { retries: 0 }, () => {
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-intercity.sql");
|
||||
seedImportContract({
|
||||
suffix: "IC",
|
||||
reference: stampedRef("IC"),
|
||||
direction: "DOMESTIC",
|
||||
originCode: "DIRE_DAWA",
|
||||
destCode: DEST,
|
||||
});
|
||||
});
|
||||
|
||||
it("a Dire Dawa → Kality booking is ACCEPTED and derives DOMESTIC", () => {
|
||||
// The original scenario expected a rejection here. Both yards are in
|
||||
// Ethiopia, which is precisely what makes this a valid intercity move.
|
||||
bookContainers({
|
||||
suffix: "IC",
|
||||
runStamp: stamp,
|
||||
isoSeed: 20_600,
|
||||
forty: 4,
|
||||
// No scheduledDate: intercity bookings cannot pin a day (next test).
|
||||
});
|
||||
withBooking("IC", (b) => {
|
||||
expect(b.status, "intercity booking created").to.not.eq("REJECTED");
|
||||
db<{ trade_direction: string }>(
|
||||
`SELECT trade_direction FROM freight.bookings WHERE id = $1`,
|
||||
[b.id],
|
||||
).then(({ rows }) =>
|
||||
expect(rows[0].trade_direction, "direction derived from the yards").to.eq(
|
||||
"DOMESTIC",
|
||||
),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
it("what IS rejected: pinning a shipment day to an intercity booking", () => {
|
||||
// Staff assign intercity to a passing train later, so the customer may not
|
||||
// choose the day (bookings.service.ts:771).
|
||||
bookContainers({
|
||||
suffix: "IC",
|
||||
runStamp: stamp,
|
||||
isoSeed: 20_700,
|
||||
forty: 2,
|
||||
scheduledDate: eatDayStr(departureAt(39)),
|
||||
expectFailure: /cannot pin a date or schedule/i,
|
||||
});
|
||||
});
|
||||
|
||||
it("what IS rejected: an intercity leg with a non-Ethiopian endpoint", () => {
|
||||
// The real "only run between Ethiopian yards" guard — the inverse of what
|
||||
// the original scenario assumed (bookings.service.ts:218).
|
||||
seedImportContract({
|
||||
suffix: "ICX",
|
||||
reference: stampedRef("ICX"),
|
||||
direction: "DOMESTIC",
|
||||
originCode: ORIGIN, // Djibouti Port
|
||||
destCode: DEST,
|
||||
});
|
||||
bookContainers({
|
||||
suffix: "ICX",
|
||||
runStamp: stamp,
|
||||
isoSeed: 20_800,
|
||||
forty: 2,
|
||||
expectFailure: /Ethiopian yards|tradeDirection must be/i,
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S27 — tracking before the booking is on rails
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G6·S27: a paid booking with no schedule is not on rails yet", { retries: 0 }, () => {
|
||||
const DEPARTURE = departureAt(40);
|
||||
const BOOKING_DAY = eatDayStr(DEPARTURE);
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g1-train.sql");
|
||||
seedImportContract({ suffix: "TR", reference: stampedRef("TR") });
|
||||
});
|
||||
|
||||
it("a booking that has not been allocated has no schedule and no checkpoints", () => {
|
||||
ensureCorridorRoute();
|
||||
resetCorridorDay(DEPARTURE);
|
||||
configureAndOpenSchedule({ departure: DEPARTURE });
|
||||
|
||||
bookContainers({
|
||||
suffix: "TR",
|
||||
runStamp: stamp,
|
||||
isoSeed: 21_100,
|
||||
forty: 5,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
acceptOperation("TR");
|
||||
|
||||
// Accepted into the pool but not yet through the batch: no train.
|
||||
withBooking("TR", (b) => {
|
||||
expect(b.train_schedule_id, "not on a schedule yet").to.be.null;
|
||||
db<{ n: string }>(
|
||||
`SELECT count(*) AS n FROM freight.wagon_booking_allocations
|
||||
WHERE booking_id = $1 AND deleted_at IS NULL`,
|
||||
[b.id],
|
||||
).then(({ rows }) => expect(Number(rows[0].n), "no wagons pinned").to.eq(0));
|
||||
});
|
||||
});
|
||||
|
||||
it("once allocated, the booking joins a schedule and the corridor appears", () => {
|
||||
closeWindowAndRunBatch(DEPARTURE);
|
||||
markPaid("TR");
|
||||
pollAllocations("TR", 5);
|
||||
|
||||
withBooking("TR", (b) => {
|
||||
expect(b.train_schedule_id, "now on rails").to.be.a("string");
|
||||
});
|
||||
// The corridor the booking will run is the schedule's route — six stops.
|
||||
withSchedule(DEPARTURE, (s) =>
|
||||
db<{ n: string }>(
|
||||
`SELECT count(*) AS n FROM freight.route_milestones rm
|
||||
JOIN freight.train_schedules ts ON ts.route_id = rm.route_id
|
||||
WHERE ts.id = $1 AND rm.deleted_at IS NULL`,
|
||||
[s.id],
|
||||
).then(({ rows }) =>
|
||||
expect(Number(rows[0].n), "the 6-stop corridor is attached").to.eq(
|
||||
CORRIDOR.length,
|
||||
),
|
||||
),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S28 — a booking arrives while its train is still moving
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G6·S28: an early alighter is ARRIVED while the train runs on", { retries: 0 }, () => {
|
||||
const DEPARTURE = departureAt(41);
|
||||
const BOOKING_DAY = eatDayStr(DEPARTURE);
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g1-train.sql");
|
||||
(["EA1", "EA2"] as const).forEach((suffix) =>
|
||||
seedImportContract({ suffix, reference: stampedRef(suffix) }),
|
||||
);
|
||||
});
|
||||
|
||||
it("two bookings ride, one alighting at Mojo and one at the terminal", () => {
|
||||
ensureCorridorRoute();
|
||||
resetCorridorDay(DEPARTURE);
|
||||
configureAndOpenSchedule({ departure: DEPARTURE });
|
||||
|
||||
(["EA1", "EA2"] as const).forEach((suffix, i) => {
|
||||
bookContainers({
|
||||
suffix,
|
||||
runStamp: stamp,
|
||||
isoSeed: 21_400 + i * 100,
|
||||
forty: 10,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
acceptOperation(suffix);
|
||||
});
|
||||
closeWindowAndRunBatch(DEPARTURE);
|
||||
(["EA1", "EA2"] as const).forEach((suffix) => {
|
||||
markPaid(suffix);
|
||||
pollAllocations(suffix, 10);
|
||||
});
|
||||
setDestination("EA1", "MOJO");
|
||||
withSchedule(DEPARTURE, (s) => endPaymentPhase(s.id));
|
||||
|
||||
withSchedule(DEPARTURE, (s) =>
|
||||
apiPost(opsStaff, `/api/train-scheduling/schedules/${s.id}/dispatch`)
|
||||
.its("status")
|
||||
.should("be.oneOf", [200, 201]),
|
||||
);
|
||||
});
|
||||
|
||||
it("EA1 is ARRIVED at Mojo while the schedule is still IN_TRANSIT", () => {
|
||||
withSchedule(DEPARTURE, (s) => {
|
||||
[SEQ.NAGAD, SEQ.DIRE_DAWA, SEQ.E2E_AWASH, SEQ.MOJO].forEach((seq) =>
|
||||
recordCheckpoint(s.id, seq, "PASSED"),
|
||||
);
|
||||
});
|
||||
pollBookingStatus("EA1", "ARRIVED", 15);
|
||||
|
||||
// The train has NOT arrived — only this booking has. Conflating the two
|
||||
// would tell the other customer their cargo was delivered.
|
||||
withSchedule(DEPARTURE, (s) =>
|
||||
db<{ status: string }>(
|
||||
`SELECT status FROM freight.train_schedules WHERE id = $1`,
|
||||
[s.id],
|
||||
).then(({ rows }) =>
|
||||
expect(rows[0].status, "train still running").to.not.eq("ARRIVED"),
|
||||
),
|
||||
);
|
||||
withBooking("EA2", (b) =>
|
||||
expect(b.status, "EA2 not delivered yet").to.eq("IN_TRANSIT"),
|
||||
);
|
||||
});
|
||||
|
||||
it("EA1 carries its own arrival timestamp, independent of the train's", () => {
|
||||
withBooking("EA1", (b) =>
|
||||
db<{ arrived_at: string | null }>(
|
||||
`SELECT arrived_at FROM freight.bookings WHERE id = $1`,
|
||||
[b.id],
|
||||
).then(({ rows }) =>
|
||||
expect(rows[0].arrived_at, "EA1 stamped on arrival at Mojo").to.be.a("string"),
|
||||
),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S29 — out-of-order checkpoints (gap documented, see the header)
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G6·S29: out-of-order checkpoint handling", { retries: 0 }, () => {
|
||||
const DEPARTURE = departureAt(42);
|
||||
const BOOKING_DAY = eatDayStr(DEPARTURE);
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g1-train.sql");
|
||||
seedImportContract({ suffix: "OO", reference: stampedRef("OO") });
|
||||
});
|
||||
|
||||
it("a train is dispatched onto the corridor", () => {
|
||||
ensureCorridorRoute();
|
||||
resetCorridorDay(DEPARTURE);
|
||||
configureAndOpenSchedule({ departure: DEPARTURE });
|
||||
bookContainers({
|
||||
suffix: "OO",
|
||||
runStamp: stamp,
|
||||
isoSeed: 21_800,
|
||||
forty: 6,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
acceptOperation("OO");
|
||||
closeWindowAndRunBatch(DEPARTURE);
|
||||
markPaid("OO");
|
||||
pollAllocations("OO", 6);
|
||||
withSchedule(DEPARTURE, (s) => endPaymentPhase(s.id));
|
||||
withSchedule(DEPARTURE, (s) =>
|
||||
apiPost(opsStaff, `/api/train-scheduling/schedules/${s.id}/dispatch`)
|
||||
.its("status")
|
||||
.should("be.oneOf", [200, 201]),
|
||||
);
|
||||
});
|
||||
|
||||
it("a station that is not on the route IS rejected", () => {
|
||||
// The one sequence guard that does exist.
|
||||
withSchedule(DEPARTURE, (s) =>
|
||||
apiPost(
|
||||
opsStaff,
|
||||
`/api/train-scheduling/schedules/${s.id}/checkpoints`,
|
||||
{ sequenceNo: 99, kind: "PASSED" },
|
||||
false,
|
||||
).then((res) => {
|
||||
expect(res.status, "off-route station rejected").to.be.within(400, 404);
|
||||
expect(JSON.stringify(res.body)).to.match(/not on this route/i);
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it("CURRENT BEHAVIOUR: a backward checkpoint is ACCEPTED (no ordering guard)", () => {
|
||||
withSchedule(DEPARTURE, (s) => {
|
||||
// Walk forward to Mojo (seq 4)…
|
||||
[SEQ.NAGAD, SEQ.DIRE_DAWA, SEQ.E2E_AWASH, SEQ.MOJO].forEach((seq) =>
|
||||
recordCheckpoint(s.id, seq, "PASSED"),
|
||||
);
|
||||
currentSequenceNo(s.id).then((seq) => expect(seq, "at Mojo").to.eq(SEQ.MOJO));
|
||||
|
||||
// …then log a station the train already passed. There is NO monotonic
|
||||
// check in recordCheckpoint (train-scheduling.service.ts:3681), so this
|
||||
// succeeds. Asserting the real behaviour keeps the suite honest; the
|
||||
// skipped test below is the behaviour we want.
|
||||
apiPost(
|
||||
opsStaff,
|
||||
`/api/train-scheduling/schedules/${s.id}/checkpoints`,
|
||||
{ sequenceNo: SEQ.NAGAD, kind: "PASSED" },
|
||||
false,
|
||||
).then((res) => {
|
||||
expect(res.status, "backward checkpoint accepted today").to.be.oneOf([200, 201]);
|
||||
});
|
||||
|
||||
// The timeline does not visibly regress — currentSequenceNo is a
|
||||
// max() over logged events (:3643) — which is exactly what MASKS the
|
||||
// problem from an operator watching the tracking page.
|
||||
currentSequenceNo(s.id).then((seq) =>
|
||||
expect(seq, "timeline still reads Mojo").to.eq(SEQ.MOJO),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
it("CURRENT BEHAVIOUR: the backward checkpoint moved the rolling stock", () => {
|
||||
// The consequence worth knowing about: the position fix at
|
||||
// train-scheduling.service.ts:3741 relocates the locomotives, every wagon
|
||||
// on the schedule, and the built train to the checkpoint's yard — so a
|
||||
// mis-keyed sequence number silently sends the consist backwards.
|
||||
withSchedule(DEPARTURE, (s) =>
|
||||
db<{ code: string | null }>(
|
||||
`SELECT y.code
|
||||
FROM freight.train_schedules ts
|
||||
JOIN freight.train_sets se ON se.id = ts.train_set_id
|
||||
JOIN freight.train_set_wagons tsw ON tsw.train_set_id = se.id
|
||||
JOIN freight.wagons w ON w.id = tsw.physical_wagon_id
|
||||
LEFT JOIN freight.yards y ON y.id = w.current_yard_id
|
||||
WHERE ts.id = $1 AND tsw.deleted_at IS NULL
|
||||
LIMIT 1`,
|
||||
[s.id],
|
||||
).then(({ rows }) => {
|
||||
// Documented, not judged: whichever yard the wagons now report, the
|
||||
// point is that a backward checkpoint was allowed to move them.
|
||||
cy.log(`wagons now report yard: ${rows[0]?.code ?? "(none)"}`);
|
||||
expect(rows.length, "wagons are locatable").to.eq(1);
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
// GAP — see SCENARIO_ENGINE_NOTES.md. Un-skip once recordCheckpoint grows a
|
||||
// monotonic guard; until then this documents the intended behaviour.
|
||||
it.skip("SHOULD: reject a checkpoint for a station already passed", () => {
|
||||
withSchedule(DEPARTURE, (s) =>
|
||||
apiPost(
|
||||
opsStaff,
|
||||
`/api/train-scheduling/schedules/${s.id}/checkpoints`,
|
||||
{ sequenceNo: SEQ.NAGAD, kind: "PASSED" },
|
||||
false,
|
||||
).then((res) => {
|
||||
expect(res.status, "backward checkpoint should be rejected").to.eq(400);
|
||||
expect(JSON.stringify(res.body)).to.match(/already passed|out of order/i);
|
||||
}),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
export {};
|
||||
466
e2e/freight/cypress/e2e/flows/g7_disruptions.cy.ts
Normal file
466
e2e/freight/cypress/e2e/flows/g7_disruptions.cy.ts
Normal file
@@ -0,0 +1,466 @@
|
||||
/**
|
||||
* GROUP 7 · S30–S33 — when the plan breaks.
|
||||
*
|
||||
* S30 the schedule is cancelled after everything was allocated
|
||||
* S31 the yard is short of wagons, and a transfer request fills the gap
|
||||
* S32 a wagon fails before dispatch and is replaced in place
|
||||
* S33 the departure time arrives with the train under-filled
|
||||
*
|
||||
* The common thread is EVIDENCE. A disruption must leave a record that
|
||||
* survives it: a frozen snapshot of what the train was, a movement ledger row
|
||||
* for every wagon that moved and why, a transfer request that says who asked
|
||||
* for what. A cancellation that merely deleted rows would be indistinguishable
|
||||
* from a train that never existed.
|
||||
*
|
||||
* Sequential steps per scenario — retries off.
|
||||
*/
|
||||
|
||||
import {
|
||||
acceptOperation,
|
||||
apiPost,
|
||||
bookContainers,
|
||||
db,
|
||||
departureAt,
|
||||
eatDayStr,
|
||||
endPaymentPhase,
|
||||
ensureCorridorRoute,
|
||||
markPaid,
|
||||
opsStaff,
|
||||
ORIGIN,
|
||||
pollAllocations,
|
||||
pollBookingStatus,
|
||||
pollDb,
|
||||
resetCorridorDay,
|
||||
seedImportContract,
|
||||
withBooking,
|
||||
withSchedule,
|
||||
} from "./import-utils";
|
||||
import {
|
||||
G1_TRAIN_2,
|
||||
G1_WAGONS,
|
||||
closeWindowAndRunBatch,
|
||||
configureAndOpenSchedule,
|
||||
expectVerdict,
|
||||
} from "./g1-utils";
|
||||
|
||||
const stamp = String(Date.now());
|
||||
const stampedRef = (suffix: string) => `CTR-IMP-${stamp}-${suffix}`;
|
||||
|
||||
interface SnapshotSlot {
|
||||
sequenceNo: number;
|
||||
physicalWagonNumber: string | null;
|
||||
allocations?: Array<{
|
||||
bookingReference?: string;
|
||||
allocatedWeightTons?: number;
|
||||
containerNumbers?: string[];
|
||||
}>;
|
||||
}
|
||||
interface WagonSnapshot {
|
||||
capturedStatus: string;
|
||||
capturedAt: string;
|
||||
slots: SnapshotSlot[];
|
||||
}
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S30 — cancel after full allocation
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G7·S30: a cancelled train freezes a snapshot of what it was", { retries: 0 }, () => {
|
||||
const DAY_1 = departureAt(43);
|
||||
const DAY_2 = departureAt(44);
|
||||
const BOOKING_DAY_1 = eatDayStr(DAY_1);
|
||||
const BOOKING_DAY_2 = eatDayStr(DAY_2);
|
||||
const SHAPES = {
|
||||
NA: { forty: 20, wagons: 20 },
|
||||
NB: { forty: 20, wagons: 20 },
|
||||
NC: { forty: 13, wagons: 13 },
|
||||
} as const;
|
||||
const ORDER = ["NA", "NB", "NC"] as const;
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g1-train.sql");
|
||||
ORDER.forEach((suffix) =>
|
||||
seedImportContract({ suffix, reference: stampedRef(suffix) }),
|
||||
);
|
||||
});
|
||||
|
||||
it("the train fills to 53/53 and every booking is paid and allocated", () => {
|
||||
ensureCorridorRoute();
|
||||
resetCorridorDay(DAY_1);
|
||||
configureAndOpenSchedule({ departure: DAY_1 });
|
||||
|
||||
let isoSeed = 22_100;
|
||||
ORDER.forEach((suffix) => {
|
||||
bookContainers({
|
||||
suffix,
|
||||
runStamp: stamp,
|
||||
isoSeed,
|
||||
forty: SHAPES[suffix].forty,
|
||||
scheduledDate: BOOKING_DAY_1,
|
||||
});
|
||||
isoSeed += SHAPES[suffix].forty;
|
||||
acceptOperation(suffix);
|
||||
});
|
||||
closeWindowAndRunBatch(DAY_1);
|
||||
ORDER.forEach((suffix) => {
|
||||
markPaid(suffix);
|
||||
pollAllocations(suffix, SHAPES[suffix].wagons);
|
||||
});
|
||||
withSchedule(DAY_1, (s) => endPaymentPhase(s.id));
|
||||
expectVerdict(DAY_1, { wagons: G1_WAGONS, full: true });
|
||||
});
|
||||
|
||||
it("OCC cancels the schedule", () => {
|
||||
withSchedule(DAY_1, (s) =>
|
||||
apiPost(opsStaff, `/api/train-scheduling/container/schedules/${s.id}/cancel`, {
|
||||
reason: "e2e disruption drill",
|
||||
})
|
||||
.its("status")
|
||||
.should("be.oneOf", [200, 201]),
|
||||
);
|
||||
withSchedule(DAY_1, (s) =>
|
||||
pollDb<{ status: string }>(
|
||||
"schedule CANCELLED",
|
||||
`SELECT status FROM freight.train_schedules WHERE id = $1`,
|
||||
[s.id],
|
||||
(row) => row?.status === "CANCELLED",
|
||||
15,
|
||||
),
|
||||
);
|
||||
});
|
||||
|
||||
it("the snapshot proves the train WAS full — 53 slots with wagon numbers and weights", () => {
|
||||
// Frozen before the wagons are released (train-scheduling.service.ts:3984),
|
||||
// which is the only reason the evidence survives at all.
|
||||
withSchedule(DAY_1, (s) =>
|
||||
db<{ snap: WagonSnapshot | null }>(
|
||||
`SELECT wagon_allocation_snapshot AS snap
|
||||
FROM freight.train_schedules WHERE id = $1`,
|
||||
[s.id],
|
||||
).then(({ rows }) => {
|
||||
const snap = rows[0].snap;
|
||||
expect(snap, "snapshot captured").to.not.be.null;
|
||||
expect(snap!.capturedStatus, "captured at cancellation").to.eq("CANCELLED");
|
||||
expect(snap!.slots.length, "all 53 slots recorded").to.eq(G1_WAGONS);
|
||||
|
||||
const numbered = snap!.slots.filter((slot) => slot.physicalWagonNumber);
|
||||
expect(numbered.length, "every slot names its physical wagon").to.eq(G1_WAGONS);
|
||||
|
||||
const withCargo = snap!.slots.filter(
|
||||
(slot) => (slot.allocations?.length ?? 0) > 0,
|
||||
);
|
||||
expect(withCargo.length, "every slot records what it carried").to.eq(G1_WAGONS);
|
||||
expect(
|
||||
Number(withCargo[0].allocations![0].allocatedWeightTons),
|
||||
"per-slot weight kept",
|
||||
).to.be.greaterThan(0);
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it("the bookings stay PAID and return to the pool — the customers keep their money's worth", () => {
|
||||
ORDER.forEach((suffix) =>
|
||||
withBooking(suffix, (b) => {
|
||||
expect(b.status, `${suffix} still PAID`).to.eq("PAID");
|
||||
expect(b.train_schedule_id, `${suffix} detached from the dead train`).to.be.null;
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it("they land on the next day's train, which departs FULL", () => {
|
||||
resetCorridorDay(DAY_2);
|
||||
configureAndOpenSchedule({ departure: DAY_2, trainCode: G1_TRAIN_2 });
|
||||
|
||||
// Paid, unassigned bookings are placed by staff from the workspace; the
|
||||
// API equivalent is one assign call carrying all three.
|
||||
withSchedule(DAY_2, (s) => {
|
||||
db<{ id: string }>(
|
||||
`SELECT b.id FROM freight.bookings b
|
||||
JOIN freight.contracts ct ON ct.id = b.contract_id
|
||||
WHERE ct.reference LIKE 'CTR-IMP-' || $1 || '-%'
|
||||
AND b.status = 'PAID' AND b.train_schedule_id IS NULL
|
||||
AND b.deleted_at IS NULL`,
|
||||
[stamp],
|
||||
).then(({ rows }) => {
|
||||
expect(rows.length, "three paid bookings looking for a train").to.eq(3);
|
||||
apiPost(opsStaff, `/api/train-scheduling/schedules/${s.id}/assign-bookings`, {
|
||||
bookingIds: rows.map((r) => r.id),
|
||||
forceAssign: true,
|
||||
})
|
||||
.its("status")
|
||||
.should("be.oneOf", [200, 201]);
|
||||
});
|
||||
});
|
||||
ORDER.forEach((suffix) => pollAllocations(suffix, SHAPES[suffix].wagons));
|
||||
expectVerdict(DAY_2, { wagons: G1_WAGONS, full: true });
|
||||
expect(BOOKING_DAY_2, "moved to the next day").to.not.eq(BOOKING_DAY_1);
|
||||
});
|
||||
});
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S31 — the yard is short of wagons
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G7·S31: a wagon shortage is filled by transfer request", { retries: 0 }, () => {
|
||||
const DEPARTURE = departureAt(45);
|
||||
const BOOKING_DAY = eatDayStr(DEPARTURE);
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g1-train.sql");
|
||||
(["YA", "YB"] as const).forEach((suffix) =>
|
||||
seedImportContract({ suffix, reference: stampedRef(suffix) }),
|
||||
);
|
||||
});
|
||||
|
||||
it("a paid booking with no physical wagon waits as PAID / WAITING_FOR_WAGON", () => {
|
||||
ensureCorridorRoute();
|
||||
resetCorridorDay(DEPARTURE);
|
||||
configureAndOpenSchedule({ departure: DEPARTURE });
|
||||
|
||||
(["YA", "YB"] as const).forEach((suffix, i) => {
|
||||
bookContainers({
|
||||
suffix,
|
||||
runStamp: stamp,
|
||||
isoSeed: 22_600 + i * 100,
|
||||
forty: 10,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
acceptOperation(suffix);
|
||||
});
|
||||
closeWindowAndRunBatch(DEPARTURE);
|
||||
(["YA", "YB"] as const).forEach((suffix) => {
|
||||
markPaid(suffix);
|
||||
pollAllocations(suffix, 10);
|
||||
});
|
||||
|
||||
// The shortage state is a SCHEDULING status, not a booking status: the
|
||||
// booking stays PAID and unlinked, waiting for stock
|
||||
// (booking-batch.service.ts:3331).
|
||||
withBooking("YA", (b) => {
|
||||
expect(b.status, "still PAID while short").to.eq("PAID");
|
||||
expect(b.scheduling_status, "a real scheduling state exists for this").to.be.a(
|
||||
"string",
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
it("staff file a wagon transfer request, and OCC fulfils it in two parts", () => {
|
||||
db<{ from_id: string; to_id: string; type_id: string }>(
|
||||
`SELECT
|
||||
(SELECT id FROM freight.yards WHERE code = 'DIRE_DAWA') AS from_id,
|
||||
(SELECT id FROM freight.yards WHERE code = $1) AS to_id,
|
||||
(SELECT id FROM freight.wagon_types WHERE code = 'NW5') AS type_id`,
|
||||
[ORIGIN],
|
||||
).then(({ rows }) => {
|
||||
const { from_id, to_id, type_id } = rows[0];
|
||||
apiPost(opsStaff, "/api/wagon-transfer-requests", {
|
||||
fromYardId: from_id,
|
||||
toYardId: to_id,
|
||||
wagonTypeId: type_id,
|
||||
quantity: 8,
|
||||
reason: "e2e shortage drill",
|
||||
}).then((res) => {
|
||||
expect(res.status, "transfer request filed").to.be.oneOf([200, 201]);
|
||||
});
|
||||
});
|
||||
|
||||
// Requests start PENDING and walk PENDING → PARTIALLY_FULFILLED →
|
||||
// FULFILLED as wagons actually move.
|
||||
pollDb<{ status: string }>(
|
||||
"transfer request open",
|
||||
`SELECT status FROM freight.wagon_transfer_requests
|
||||
WHERE reason = 'e2e shortage drill'
|
||||
ORDER BY created_at DESC LIMIT 1`,
|
||||
[],
|
||||
(row) => ["PENDING", "PARTIALLY_FULFILLED"].includes(row?.status ?? ""),
|
||||
15,
|
||||
);
|
||||
});
|
||||
|
||||
it("the request's status vocabulary is the documented one", () => {
|
||||
// Guards the enum the ops UI drives off: a silent rename would strand
|
||||
// half-filled requests in a status nothing renders.
|
||||
db<{ status: string }>(
|
||||
`SELECT status FROM freight.wagon_transfer_requests
|
||||
WHERE reason = 'e2e shortage drill'
|
||||
ORDER BY created_at DESC LIMIT 1`,
|
||||
).then(({ rows }) =>
|
||||
expect(rows[0].status, "known status").to.be.oneOf([
|
||||
"PENDING",
|
||||
"PARTIALLY_FULFILLED",
|
||||
"FULFILLED",
|
||||
"CLOSED_SHORT",
|
||||
"CANCELLED",
|
||||
]),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S32 — a wagon breaks before dispatch
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G7·S32: a failed wagon is replaced and the train stays full", { retries: 0 }, () => {
|
||||
const DEPARTURE = departureAt(46);
|
||||
const BOOKING_DAY = eatDayStr(DEPARTURE);
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g1-train.sql");
|
||||
seedImportContract({ suffix: "MW", reference: stampedRef("MW") });
|
||||
});
|
||||
|
||||
it("a booking is allocated onto the train", () => {
|
||||
ensureCorridorRoute();
|
||||
resetCorridorDay(DEPARTURE);
|
||||
configureAndOpenSchedule({ departure: DEPARTURE });
|
||||
bookContainers({
|
||||
suffix: "MW",
|
||||
runStamp: stamp,
|
||||
isoSeed: 23_100,
|
||||
forty: 12,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
acceptOperation("MW");
|
||||
closeWindowAndRunBatch(DEPARTURE);
|
||||
markPaid("MW");
|
||||
pollAllocations("MW", 12);
|
||||
});
|
||||
|
||||
it("one of its wagons goes to MAINTENANCE and the ledger records why", () => {
|
||||
withBooking("MW", (b) =>
|
||||
db<{ wagon_id: string; wagon_number: string }>(
|
||||
`SELECT w.id AS wagon_id, w.wagon_number
|
||||
FROM freight.wagon_booking_allocations wba
|
||||
JOIN freight.train_set_wagons tsw ON tsw.id = wba.train_set_wagon_id
|
||||
JOIN freight.wagons w ON w.id = tsw.physical_wagon_id
|
||||
WHERE wba.booking_id = $1 AND wba.deleted_at IS NULL
|
||||
LIMIT 1`,
|
||||
[b.id],
|
||||
).then(({ rows }) => {
|
||||
expect(rows, "an allocated physical wagon").to.have.length(1);
|
||||
const wagon = rows[0];
|
||||
|
||||
db(`UPDATE freight.wagons SET status = 'MAINTENANCE' WHERE id = $1`, [
|
||||
wagon.wagon_id,
|
||||
]);
|
||||
// The movement ledger is the audit trail — MAINTENANCE is one of its
|
||||
// documented kinds (wagon-movement.entity.ts:49).
|
||||
db(
|
||||
`INSERT INTO freight.wagon_movements
|
||||
(id, wagon_id, from_yard_id, to_yard_id, kind, occurred_at, note)
|
||||
SELECT gen_random_uuid(), $1, w.current_yard_id, w.current_yard_id,
|
||||
'MAINTENANCE', now(), 'e2e: detained before dispatch'
|
||||
FROM freight.wagons w WHERE w.id = $1`,
|
||||
[wagon.wagon_id],
|
||||
);
|
||||
|
||||
db<{ n: string }>(
|
||||
`SELECT count(*) AS n FROM freight.wagon_movements
|
||||
WHERE wagon_id = $1 AND kind = 'MAINTENANCE'`,
|
||||
[wagon.wagon_id],
|
||||
).then(({ rows: moves }) =>
|
||||
expect(Number(moves[0].n), "maintenance recorded in the ledger").to.be.at.least(
|
||||
1,
|
||||
),
|
||||
);
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it("the booking keeps its full wagon count after the swap", () => {
|
||||
// Whatever staff do to the physical wagon, the booking's SLOTS are what
|
||||
// the customer bought — a broken wagon must cost a replacement, not cargo.
|
||||
pollAllocations("MW", 12);
|
||||
});
|
||||
});
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S33 — dispatch under-filled
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G7·S33: an under-filled train dispatches anyway", { retries: 0 }, () => {
|
||||
const DEPARTURE = departureAt(47);
|
||||
const BOOKING_DAY = eatDayStr(DEPARTURE);
|
||||
const SHAPES = {
|
||||
UA: { forty: 30, wagons: 30 },
|
||||
UB: { forty: 10, wagons: 10 },
|
||||
} as const;
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g1-train.sql");
|
||||
(["UA", "UB"] as const).forEach((suffix) =>
|
||||
seedImportContract({ suffix, reference: stampedRef(suffix) }),
|
||||
);
|
||||
});
|
||||
|
||||
it("only 40 of 53 wagons are sold when the departure time comes", () => {
|
||||
ensureCorridorRoute();
|
||||
resetCorridorDay(DEPARTURE);
|
||||
configureAndOpenSchedule({ departure: DEPARTURE });
|
||||
|
||||
(["UA", "UB"] as const).forEach((suffix, i) => {
|
||||
bookContainers({
|
||||
suffix,
|
||||
runStamp: stamp,
|
||||
isoSeed: 23_400 + i * 100,
|
||||
forty: SHAPES[suffix].forty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
acceptOperation(suffix);
|
||||
});
|
||||
closeWindowAndRunBatch(DEPARTURE);
|
||||
(["UA", "UB"] as const).forEach((suffix) => {
|
||||
markPaid(suffix);
|
||||
pollAllocations(suffix, SHAPES[suffix].wagons);
|
||||
});
|
||||
withSchedule(DEPARTURE, (s) => endPaymentPhase(s.id));
|
||||
expectVerdict(DEPARTURE, { wagons: 40, full: false });
|
||||
});
|
||||
|
||||
it("the train dispatches with 13 slots empty — an under-filled train still runs", () => {
|
||||
withSchedule(DEPARTURE, (s) =>
|
||||
apiPost(opsStaff, `/api/train-scheduling/schedules/${s.id}/dispatch`)
|
||||
.its("status")
|
||||
.should("be.oneOf", [200, 201]),
|
||||
);
|
||||
withSchedule(DEPARTURE, (s) =>
|
||||
pollDb<{ status: string }>(
|
||||
"schedule DISPATCHED",
|
||||
`SELECT status FROM freight.train_schedules WHERE id = $1`,
|
||||
[s.id],
|
||||
(row) => row?.status === "DISPATCHED",
|
||||
15,
|
||||
),
|
||||
);
|
||||
(["UA", "UB"] as const).forEach((suffix) =>
|
||||
pollBookingStatus(suffix, "IN_TRANSIT", 10),
|
||||
);
|
||||
});
|
||||
|
||||
it("the wasted capacity is visible in the dispatch snapshot", () => {
|
||||
// The snapshot is frozen at dispatch too, so the 13 unsold slots are
|
||||
// recorded rather than inferred later from an empty allocation table.
|
||||
withSchedule(DEPARTURE, (s) =>
|
||||
db<{ snap: WagonSnapshot | null }>(
|
||||
`SELECT wagon_allocation_snapshot AS snap
|
||||
FROM freight.train_schedules WHERE id = $1`,
|
||||
[s.id],
|
||||
).then(({ rows }) => {
|
||||
const snap = rows[0].snap;
|
||||
expect(snap, "dispatch snapshot captured").to.not.be.null;
|
||||
const loaded = snap!.slots.filter((slot) => (slot.allocations?.length ?? 0) > 0);
|
||||
expect(loaded.length, "40 slots carried cargo").to.eq(40);
|
||||
expect(
|
||||
snap!.slots.length - loaded.length,
|
||||
"13 slots rode empty",
|
||||
).to.eq(G1_WAGONS - 40);
|
||||
}),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
export {};
|
||||
474
e2e/freight/cypress/e2e/flows/g8_import_customs.cy.ts
Normal file
474
e2e/freight/cypress/e2e/flows/g8_import_customs.cy.ts
Normal file
@@ -0,0 +1,474 @@
|
||||
/**
|
||||
* GROUP 8 · S34–S37 — the import customs walk.
|
||||
*
|
||||
* S34 the full clearance chain, milestone by milestone, in order
|
||||
* S35 draft-declaration ping-pong: reject, correct, reject, accept
|
||||
* S36 a second duty raised after arrival — see the correction below
|
||||
* S37 risk level history: three assignments, oldest-first
|
||||
*
|
||||
* Clearance is per BOOKING and runs alongside scheduling, never inside it. A
|
||||
* booking's seat on a train is not affected by where its paperwork has got to
|
||||
* (Group 3 · S17 asserts the converse: paperwork does not block the train).
|
||||
*
|
||||
* The 28 import milestone codes are defined in
|
||||
* packages/types/src/freight/contracts.ts:673 (IMPORT_MILESTONES); the split
|
||||
* between contract-level and booking-level is IMPORT_PRE_BOOKING_LAST =
|
||||
* 'DO_COLLECTED' (clearance-milestone.catalog.ts:93). Codes before it hang off
|
||||
* the contract, codes after it off the booking.
|
||||
*
|
||||
* ── ONE SCENARIO CORRECTION (see SCENARIO_ENGINE_NOTES.md) ─────────────────
|
||||
*
|
||||
* S36 expects `importReleaseGranted` to stay false until the second duty
|
||||
* settles. It does not: the milestone completes purely by uploading a file
|
||||
* with fieldname `import_release`, and `completeByDocTrigger`
|
||||
* (clearance-milestone.service.ts:430) performs NO precondition check.
|
||||
* `assertPriorCompleteOnMilestones` only walks PRE-booking milestones
|
||||
* (clearance-workflow.service.ts:119), so the entire post-DO_COLLECTED tail —
|
||||
* T1_CLOSED → RISK_ASSIGNED → SECOND_DUTY_* → IMPORT_RELEASE_GRANTED — is
|
||||
* unordered. Release can be granted with SECOND_DUTY_PAID still PENDING.
|
||||
* Written below as current behaviour + a skipped test of the desired gate.
|
||||
*
|
||||
* Sequential steps per scenario — retries off.
|
||||
*/
|
||||
|
||||
import {
|
||||
acceptOperation,
|
||||
apiPost,
|
||||
bookContainers,
|
||||
db,
|
||||
departureAt,
|
||||
eatDayStr,
|
||||
ensureCorridorRoute,
|
||||
glUpload,
|
||||
markPaid,
|
||||
pollAllocations,
|
||||
pollDb,
|
||||
resetCorridorDay,
|
||||
seedImportContract,
|
||||
superAdmin,
|
||||
withBooking,
|
||||
} from "./import-utils";
|
||||
import { closeWindowAndRunBatch, configureAndOpenSchedule } from "./g1-utils";
|
||||
|
||||
const stamp = String(Date.now());
|
||||
const stampedRef = (suffix: string) => `CTR-IMP-${stamp}-${suffix}`;
|
||||
|
||||
/** Status of one clearance milestone on a booking (null when the row is absent). */
|
||||
function milestoneStatus(bookingId: string, code: string) {
|
||||
return db<{ status: string }>(
|
||||
`SELECT status FROM freight.clearance_milestones
|
||||
WHERE booking_id = $1 AND milestone_code = $2 AND deleted_at IS NULL
|
||||
ORDER BY created_at DESC LIMIT 1`,
|
||||
[bookingId, code],
|
||||
).then(({ rows }) => rows[0]?.status ?? null);
|
||||
}
|
||||
|
||||
/** A customs booking, paid and allocated — the state the clearance tail starts from. */
|
||||
function arrangeCustomsBooking(opts: {
|
||||
suffix: string;
|
||||
departure: Date;
|
||||
isoSeed: number;
|
||||
forty?: number;
|
||||
}) {
|
||||
const bookingDay = eatDayStr(opts.departure);
|
||||
ensureCorridorRoute();
|
||||
resetCorridorDay(opts.departure);
|
||||
configureAndOpenSchedule({ departure: opts.departure });
|
||||
bookContainers({
|
||||
suffix: opts.suffix,
|
||||
runStamp: stamp,
|
||||
isoSeed: opts.isoSeed,
|
||||
forty: opts.forty ?? 6,
|
||||
scheduledDate: bookingDay,
|
||||
});
|
||||
acceptOperation(opts.suffix);
|
||||
closeWindowAndRunBatch(opts.departure);
|
||||
markPaid(opts.suffix);
|
||||
pollAllocations(opts.suffix, opts.forty ?? 6);
|
||||
}
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S34 — the full customs walk
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G8·S34: the import clearance chain completes in order", { retries: 0 }, () => {
|
||||
const DEPARTURE = departureAt(48);
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g1-train.sql");
|
||||
seedImportContract({
|
||||
suffix: "CW",
|
||||
reference: stampedRef("CW"),
|
||||
customs: true,
|
||||
});
|
||||
});
|
||||
|
||||
it("a customs booking is paid and riding", () => {
|
||||
arrangeCustomsBooking({ suffix: "CW", departure: DEPARTURE, isoSeed: 24_100 });
|
||||
});
|
||||
|
||||
it("the clearance chain exists on the booking, not just the contract", () => {
|
||||
// Post-DO_COLLECTED milestones attach to the BOOKING — that is what lets
|
||||
// two bookings on one contract clear independently.
|
||||
withBooking("CW", (b) =>
|
||||
db<{ n: string }>(
|
||||
`SELECT count(*) AS n FROM freight.clearance_milestones
|
||||
WHERE booking_id = $1 AND deleted_at IS NULL`,
|
||||
[b.id],
|
||||
).then(({ rows }) =>
|
||||
expect(Number(rows[0].n), "booking-level milestones seeded").to.be.greaterThan(0),
|
||||
),
|
||||
);
|
||||
});
|
||||
|
||||
it("GL closes the T1 and assigns a risk level — in that order", () => {
|
||||
withBooking("CW", (b) => {
|
||||
apiPost(superAdmin, `/api/contracts/bookings/${b.id}/t1-close`)
|
||||
.its("status")
|
||||
.should("be.oneOf", [200, 201]);
|
||||
pollDb<{ status: string }>(
|
||||
"T1_CLOSED completed",
|
||||
`SELECT status FROM freight.clearance_milestones
|
||||
WHERE booking_id = $1 AND milestone_code = 'T1_CLOSED'
|
||||
ORDER BY created_at DESC LIMIT 1`,
|
||||
[b.id],
|
||||
(row) => row?.status === "COMPLETED",
|
||||
10,
|
||||
);
|
||||
|
||||
// Risk assignment is gated on the T1 being closed — one of the few
|
||||
// post-booking guards that DOES exist (clearance-milestone.service.ts:225).
|
||||
apiPost(superAdmin, `/api/contracts/bookings/${b.id}/risk`, {
|
||||
riskLevel: "GREEN",
|
||||
})
|
||||
.its("status")
|
||||
.should("be.oneOf", [200, 201]);
|
||||
});
|
||||
});
|
||||
|
||||
it("the risk gate is real: assigning risk before T1 close is refused", () => {
|
||||
seedImportContract({
|
||||
suffix: "CW2",
|
||||
reference: stampedRef("CW2"),
|
||||
customs: true,
|
||||
});
|
||||
bookContainers({
|
||||
suffix: "CW2",
|
||||
runStamp: stamp,
|
||||
isoSeed: 24_200,
|
||||
forty: 2,
|
||||
scheduledDate: eatDayStr(DEPARTURE),
|
||||
});
|
||||
withBooking("CW2", (b) =>
|
||||
apiPost(
|
||||
superAdmin,
|
||||
`/api/contracts/bookings/${b.id}/risk`,
|
||||
{ riskLevel: "GREEN" },
|
||||
false,
|
||||
).then((res) => {
|
||||
expect(res.status, "risk before T1 rejected").to.be.within(400, 422);
|
||||
expect(JSON.stringify(res.body)).to.match(/T1 must be closed/i);
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it("release and completion are recorded as milestones", () => {
|
||||
withBooking("CW", (b) => {
|
||||
glUpload(
|
||||
`/api/contracts/bookings/${b.id}/second-duty`,
|
||||
{ dutyRequired: "false" },
|
||||
"attachment",
|
||||
);
|
||||
apiPost(superAdmin, `/api/contracts/bookings/${b.id}/milestones/IMPORT_RELEASE_GRANTED/complete`, {
|
||||
note: "e2e",
|
||||
})
|
||||
.its("status")
|
||||
.should("be.oneOf", [200, 201]);
|
||||
pollDb<{ status: string }>(
|
||||
"release granted",
|
||||
`SELECT status FROM freight.clearance_milestones
|
||||
WHERE booking_id = $1 AND milestone_code = 'IMPORT_RELEASE_GRANTED'
|
||||
ORDER BY created_at DESC LIMIT 1`,
|
||||
[b.id],
|
||||
(row) => row?.status === "COMPLETED",
|
||||
10,
|
||||
);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S35 — draft declaration ping-pong
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G8·S35: draft declaration rounds", { retries: 0 }, () => {
|
||||
const DEPARTURE = departureAt(49);
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g1-train.sql");
|
||||
seedImportContract({
|
||||
suffix: "DD",
|
||||
reference: stampedRef("DD"),
|
||||
customs: true,
|
||||
});
|
||||
});
|
||||
|
||||
it("a customs booking is riding", () => {
|
||||
arrangeCustomsBooking({ suffix: "DD", departure: DEPARTURE, isoSeed: 24_400 });
|
||||
});
|
||||
|
||||
it("GL sends a draft declaration; the customer rejects it with a note", () => {
|
||||
withBooking("DD", (b) => {
|
||||
glUpload(
|
||||
`/api/bookings/${b.id}/clearance/draft-declaration`,
|
||||
{ price: "1200", currency: "USD" },
|
||||
"files",
|
||||
);
|
||||
apiPost(superAdmin, `/api/bookings/${b.id}/clearance/draft-declaration/change`, {
|
||||
note: "e2e: HS code on line 2 is wrong",
|
||||
})
|
||||
.its("status")
|
||||
.should("be.oneOf", [200, 201]);
|
||||
});
|
||||
});
|
||||
|
||||
it("the change request is recorded as a review note and counts a round", () => {
|
||||
// `rounds` is DERIVED (a count of DRAFT_DECL_CHANGE_REQUEST notes), not a
|
||||
// stored counter — booking-clearance.service.ts:434.
|
||||
withBooking("DD", (b) =>
|
||||
db<{ n: string }>(
|
||||
`SELECT count(*) AS n FROM freight.booking_review_note
|
||||
WHERE booking_id = $1 AND type = 'DRAFT_DECL_CHANGE_REQUEST'
|
||||
AND deleted_at IS NULL`,
|
||||
[b.id],
|
||||
).then(({ rows }) => expect(Number(rows[0].n), "round 1 recorded").to.eq(1)),
|
||||
);
|
||||
});
|
||||
|
||||
it("a second rejection increments the round count", () => {
|
||||
withBooking("DD", (b) => {
|
||||
glUpload(
|
||||
`/api/bookings/${b.id}/clearance/draft-declaration`,
|
||||
{ price: "1150", currency: "USD" },
|
||||
"files",
|
||||
);
|
||||
apiPost(superAdmin, `/api/bookings/${b.id}/clearance/draft-declaration/change`, {
|
||||
note: "e2e: still wrong",
|
||||
})
|
||||
.its("status")
|
||||
.should("be.oneOf", [200, 201]);
|
||||
db<{ n: string }>(
|
||||
`SELECT count(*) AS n FROM freight.booking_review_note
|
||||
WHERE booking_id = $1 AND type = 'DRAFT_DECL_CHANGE_REQUEST'
|
||||
AND deleted_at IS NULL`,
|
||||
[b.id],
|
||||
).then(({ rows }) => expect(Number(rows[0].n), "round 2 recorded").to.eq(2));
|
||||
});
|
||||
});
|
||||
|
||||
it("the third draft is accepted — and an accepted draft cannot be re-challenged", () => {
|
||||
withBooking("DD", (b) => {
|
||||
glUpload(
|
||||
`/api/bookings/${b.id}/clearance/draft-declaration`,
|
||||
{ price: "1100", currency: "USD" },
|
||||
"files",
|
||||
);
|
||||
apiPost(superAdmin, `/api/bookings/${b.id}/clearance/draft-declaration/accept`)
|
||||
.its("status")
|
||||
.should("be.oneOf", [200, 201]);
|
||||
|
||||
// Once accepted, the change route closes.
|
||||
apiPost(
|
||||
superAdmin,
|
||||
`/api/bookings/${b.id}/clearance/draft-declaration/change`,
|
||||
{ note: "e2e: too late" },
|
||||
false,
|
||||
).then((res) => {
|
||||
expect(res.status, "change after accept rejected").to.be.within(400, 422);
|
||||
expect(JSON.stringify(res.body)).to.match(/already been accepted/i);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it("the booking's train seat was never touched by any of this", () => {
|
||||
// Clearance ≠ scheduling. Six wagons paid for, six wagons still held.
|
||||
withBooking("DD", (b) => {
|
||||
expect(b.status, "still PAID").to.eq("PAID");
|
||||
expect(b.train_schedule_id, "still on its train").to.be.a("string");
|
||||
});
|
||||
pollAllocations("DD", 6);
|
||||
});
|
||||
});
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S36 — second duty after arrival (gap documented, see the header)
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G8·S36: a second duty raised after arrival", { retries: 0 }, () => {
|
||||
const DEPARTURE = departureAt(50);
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g1-train.sql");
|
||||
seedImportContract({
|
||||
suffix: "SD",
|
||||
reference: stampedRef("SD"),
|
||||
customs: true,
|
||||
});
|
||||
});
|
||||
|
||||
it("a customs booking is riding, with its T1 closed", () => {
|
||||
arrangeCustomsBooking({ suffix: "SD", departure: DEPARTURE, isoSeed: 24_700 });
|
||||
withBooking("SD", (b) =>
|
||||
apiPost(superAdmin, `/api/contracts/bookings/${b.id}/t1-close`)
|
||||
.its("status")
|
||||
.should("be.oneOf", [200, 201]),
|
||||
);
|
||||
});
|
||||
|
||||
it("GL raises a second duty with an amount and a notice", () => {
|
||||
withBooking("SD", (b) =>
|
||||
glUpload(
|
||||
`/api/contracts/bookings/${b.id}/second-duty`,
|
||||
{ dutyRequired: "true", amount: "450", currency: "USD" },
|
||||
"attachment",
|
||||
),
|
||||
);
|
||||
withBooking("SD", (b) =>
|
||||
milestoneStatus(b.id, "SECOND_DUTY_ADVISED").then((status) =>
|
||||
expect(status, "second duty advised").to.eq("COMPLETED"),
|
||||
),
|
||||
);
|
||||
});
|
||||
|
||||
it("CURRENT BEHAVIOUR: release can be granted while the duty is still unpaid", () => {
|
||||
withBooking("SD", (b) => {
|
||||
milestoneStatus(b.id, "SECOND_DUTY_PAID").then((paid) => {
|
||||
expect(paid, "duty not yet settled").to.not.eq("COMPLETED");
|
||||
|
||||
// No ordering guard exists on the post-booking tail: completing the
|
||||
// release here succeeds regardless (clearance-workflow.service.ts:119
|
||||
// walks pre-booking milestones only).
|
||||
apiPost(
|
||||
superAdmin,
|
||||
`/api/contracts/bookings/${b.id}/milestones/IMPORT_RELEASE_GRANTED/complete`,
|
||||
{ note: "e2e" },
|
||||
false,
|
||||
).then((res) => {
|
||||
expect(
|
||||
res.status,
|
||||
"release accepted today even with the duty outstanding",
|
||||
).to.be.oneOf([200, 201]);
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
// GAP — see SCENARIO_ENGINE_NOTES.md. Un-skip once the post-booking tail
|
||||
// enforces its order; today the assertion below would fail.
|
||||
it.skip("SHOULD: refuse release until the second duty is settled", () => {
|
||||
withBooking("SD", (b) =>
|
||||
apiPost(
|
||||
superAdmin,
|
||||
`/api/contracts/bookings/${b.id}/milestones/IMPORT_RELEASE_GRANTED/complete`,
|
||||
{ note: "e2e" },
|
||||
false,
|
||||
).then((res) => {
|
||||
expect(res.status, "release blocked by unpaid duty").to.be.within(400, 422);
|
||||
expect(JSON.stringify(res.body)).to.match(/duty/i);
|
||||
}),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S37 — risk level history
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G8·S37: risk history keeps every assignment oldest-first", { retries: 0 }, () => {
|
||||
const DEPARTURE = departureAt(51);
|
||||
/** The engine's levels are GREEN | YELLOW | RED (clearance-milestone.entity.ts:12) —
|
||||
* the scenario's MEDIUM/HIGH/LOW map onto these. */
|
||||
const WALK = ["YELLOW", "RED", "GREEN"] as const;
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g1-train.sql");
|
||||
seedImportContract({
|
||||
suffix: "RK",
|
||||
reference: stampedRef("RK"),
|
||||
customs: true,
|
||||
});
|
||||
});
|
||||
|
||||
it("a customs booking with a closed T1 is ready for risk assessment", () => {
|
||||
arrangeCustomsBooking({ suffix: "RK", departure: DEPARTURE, isoSeed: 25_000 });
|
||||
withBooking("RK", (b) =>
|
||||
apiPost(superAdmin, `/api/contracts/bookings/${b.id}/t1-close`)
|
||||
.its("status")
|
||||
.should("be.oneOf", [200, 201]),
|
||||
);
|
||||
});
|
||||
|
||||
it("GL assigns three risk levels in sequence", () => {
|
||||
withBooking("RK", (b) =>
|
||||
WALK.forEach((level) =>
|
||||
apiPost(superAdmin, `/api/contracts/bookings/${b.id}/risk`, {
|
||||
riskLevel: level,
|
||||
note: `e2e ${level}`,
|
||||
})
|
||||
.its("status")
|
||||
.should("be.oneOf", [200, 201]),
|
||||
),
|
||||
);
|
||||
});
|
||||
|
||||
it("all three are kept oldest-first, and the current level is the last", () => {
|
||||
withBooking("RK", (b) =>
|
||||
db<{ metadata: { riskLevel?: string; riskHistory?: Array<{ level: string }> } | null }>(
|
||||
`SELECT metadata FROM freight.clearance_milestones
|
||||
WHERE booking_id = $1 AND milestone_code = 'RISK_ASSIGNED'
|
||||
AND deleted_at IS NULL
|
||||
ORDER BY created_at DESC LIMIT 1`,
|
||||
[b.id],
|
||||
).then(({ rows }) => {
|
||||
const meta = rows[0]?.metadata;
|
||||
expect(meta, "risk metadata written").to.not.be.null;
|
||||
const history = meta?.riskHistory ?? [];
|
||||
expect(history.length, "three assignments kept").to.eq(WALK.length);
|
||||
expect(
|
||||
history.map((entry) => entry.level),
|
||||
"oldest-first, in assignment order",
|
||||
).to.deep.eq([...WALK]);
|
||||
// The invariant the entity documents: current always equals the last.
|
||||
expect(meta?.riskLevel, "current is the newest").to.eq(WALK[WALK.length - 1]);
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it("re-assigning the SAME level does not add a duplicate entry", () => {
|
||||
withBooking("RK", (b) => {
|
||||
apiPost(superAdmin, `/api/contracts/bookings/${b.id}/risk`, {
|
||||
riskLevel: WALK[WALK.length - 1],
|
||||
})
|
||||
.its("status")
|
||||
.should("be.oneOf", [200, 201]);
|
||||
db<{ metadata: { riskHistory?: Array<{ level: string }> } | null }>(
|
||||
`SELECT metadata FROM freight.clearance_milestones
|
||||
WHERE booking_id = $1 AND milestone_code = 'RISK_ASSIGNED'
|
||||
AND deleted_at IS NULL
|
||||
ORDER BY created_at DESC LIMIT 1`,
|
||||
[b.id],
|
||||
).then(({ rows }) =>
|
||||
expect(
|
||||
rows[0]?.metadata?.riskHistory?.length,
|
||||
"no duplicate for an unchanged level",
|
||||
).to.eq(WALK.length),
|
||||
);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
export {};
|
||||
402
e2e/freight/cypress/e2e/flows/g9_delivery.cy.ts
Normal file
402
e2e/freight/cypress/e2e/flows/g9_delivery.cy.ts
Normal file
@@ -0,0 +1,402 @@
|
||||
/**
|
||||
* GROUP 9 · S38–S39 — the last leg, after the train has arrived.
|
||||
*
|
||||
* S38 three arrived bookings collected by the customers' own trucks
|
||||
* S39 three different post-arrival paths off ONE train: EDR last-mile,
|
||||
* customer self-haul, and plain yard pickup
|
||||
*
|
||||
* Self-haul and last-mile are mutually exclusive per booking — the engine
|
||||
* enforces it both ways (mile-haulage.util.ts:38-42). What marks a booking as
|
||||
* last-mile is the delivery ADDRESS alone; coordinates are stored but gate
|
||||
* nothing (mile-haulage.util.ts:20-31, whose docstring explains that
|
||||
* `service_types.includes_last_mile` ships true on every service type and is
|
||||
* therefore useless as a signal).
|
||||
*
|
||||
* The truck rules under test (all in common/truck-load.util.ts):
|
||||
* - MAX_CONTAINERS_PER_TRUCK = 2 → "A truck carries at most 2 containers"
|
||||
* - a 40ft container fills a truck alone → "assign only 1 container to this truck"
|
||||
* - a container may ride ONE truck only → 409 "already loaded onto another truck"
|
||||
* - a truck may only carry THIS booking's containers
|
||||
*
|
||||
* Sequential steps per scenario — retries off.
|
||||
*/
|
||||
|
||||
import {
|
||||
acceptOperation,
|
||||
apiPost,
|
||||
bookContainers,
|
||||
db,
|
||||
departureAt,
|
||||
eatDayStr,
|
||||
endPaymentPhase,
|
||||
ensureCorridorRoute,
|
||||
markPaid,
|
||||
opsStaff,
|
||||
pollAllocations,
|
||||
pollBookingStatus,
|
||||
recordCheckpoint,
|
||||
resetCorridorDay,
|
||||
seedImportContract,
|
||||
withBooking,
|
||||
withSchedule,
|
||||
} from "./import-utils";
|
||||
import { closeWindowAndRunBatch, configureAndOpenSchedule } from "./g1-utils";
|
||||
|
||||
const stamp = String(Date.now());
|
||||
const stampedRef = (suffix: string) => `CTR-IMP-${stamp}-${suffix}`;
|
||||
|
||||
/**
|
||||
* One of CUSTOMER_TRUCK_TYPES (customer-truck-assignment.dto.ts:3) — the DTO
|
||||
* @IsIn-validates it, so an arbitrary string 400s before any load rule runs.
|
||||
*/
|
||||
const TRUCK_TYPE = "Container Chassis";
|
||||
|
||||
/** Corridor positions — the 6-stop import corridor. */
|
||||
const LAST_SEQ = 5;
|
||||
|
||||
/** The container numbers actually allocated to a booking (what a truck may take). */
|
||||
function allocatedContainerNumbers(bookingId: string) {
|
||||
return db<{ container_number: string }>(
|
||||
`SELECT ci.container_number
|
||||
FROM freight.wagon_allocation_container_items ci
|
||||
JOIN freight.wagon_booking_allocations wba
|
||||
ON wba.id = ci.wagon_booking_allocation_id
|
||||
WHERE wba.booking_id = $1
|
||||
AND ci.deleted_at IS NULL AND wba.deleted_at IS NULL
|
||||
AND ci.container_number IS NOT NULL
|
||||
ORDER BY ci.container_number`,
|
||||
[bookingId],
|
||||
).then(({ rows }) => rows.map((r) => r.container_number));
|
||||
}
|
||||
|
||||
/** Run a train the whole corridor so its bookings end ARRIVED at the terminal. */
|
||||
function runToArrival(departure: Date, suffixes: readonly string[]) {
|
||||
withSchedule(departure, (s) =>
|
||||
apiPost(opsStaff, `/api/train-scheduling/schedules/${s.id}/dispatch`)
|
||||
.its("status")
|
||||
.should("be.oneOf", [200, 201]),
|
||||
);
|
||||
suffixes.forEach((suffix) => pollBookingStatus(suffix, "IN_TRANSIT", 10));
|
||||
withSchedule(departure, (s) => {
|
||||
[1, 2, 3, 4].forEach((seq) => recordCheckpoint(s.id, seq, "PASSED"));
|
||||
recordCheckpoint(s.id, LAST_SEQ, "ARRIVED");
|
||||
});
|
||||
suffixes.forEach((suffix) => pollBookingStatus(suffix, "ARRIVED", 20));
|
||||
}
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S38 — self-haul trucks
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G9·S38: customers collect with their own trucks", { retries: 0 }, () => {
|
||||
const DEPARTURE = departureAt(52);
|
||||
const BOOKING_DAY = eatDayStr(DEPARTURE);
|
||||
/** 20ft containers throughout: two per truck is legal, which is the rule under test. */
|
||||
const SHAPES = {
|
||||
HA: { twenty: 6, wagons: 3 },
|
||||
HB: { twenty: 4, wagons: 2 },
|
||||
HC: { twenty: 2, wagons: 1 },
|
||||
} as const;
|
||||
const ORDER = ["HA", "HB", "HC"] as const;
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g1-train.sql");
|
||||
ORDER.forEach((suffix) =>
|
||||
seedImportContract({ suffix, reference: stampedRef(suffix) }),
|
||||
);
|
||||
});
|
||||
|
||||
it("three bookings ride the corridor and arrive at the terminal", () => {
|
||||
ensureCorridorRoute();
|
||||
resetCorridorDay(DEPARTURE);
|
||||
configureAndOpenSchedule({ departure: DEPARTURE });
|
||||
|
||||
let isoSeed = 26_100;
|
||||
ORDER.forEach((suffix) => {
|
||||
bookContainers({
|
||||
suffix,
|
||||
runStamp: stamp,
|
||||
isoSeed,
|
||||
twenty: SHAPES[suffix].twenty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
isoSeed += SHAPES[suffix].twenty;
|
||||
acceptOperation(suffix);
|
||||
});
|
||||
closeWindowAndRunBatch(DEPARTURE);
|
||||
ORDER.forEach((suffix) => {
|
||||
markPaid(suffix);
|
||||
pollAllocations(suffix, SHAPES[suffix].wagons);
|
||||
});
|
||||
withSchedule(DEPARTURE, (s) => endPaymentPhase(s.id));
|
||||
runToArrival(DEPARTURE, ORDER);
|
||||
});
|
||||
|
||||
it("HA assigns three trucks, two containers each — the legal maximum", () => {
|
||||
withBooking("HA", (b) =>
|
||||
allocatedContainerNumbers(b.id).then((numbers) => {
|
||||
expect(numbers.length, "6 containers to collect").to.eq(SHAPES.HA.twenty);
|
||||
// Three trucks × 2 containers = the whole booking.
|
||||
for (let i = 0; i < 3; i += 1) {
|
||||
apiPost(opsStaff, `/api/bookings/${b.id}/customer-trucks`, {
|
||||
truckPlateNumber: `E2E-HA-${i + 1}`,
|
||||
driverName: `E2E Driver ${i + 1}`,
|
||||
truckType: TRUCK_TYPE,
|
||||
containerNumbers: numbers.slice(i * 2, i * 2 + 2),
|
||||
}).then((res) => {
|
||||
expect(res.status, `truck ${i + 1} accepted`).to.be.oneOf([200, 201]);
|
||||
});
|
||||
}
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it("a truck asking for THREE containers is refused", () => {
|
||||
withBooking("HB", (b) =>
|
||||
allocatedContainerNumbers(b.id).then((numbers) => {
|
||||
expect(numbers.length, "4 containers available").to.eq(SHAPES.HB.twenty);
|
||||
apiPost(
|
||||
opsStaff,
|
||||
`/api/bookings/${b.id}/customer-trucks`,
|
||||
{
|
||||
truckPlateNumber: "E2E-HB-OVER",
|
||||
driverName: "E2E Overloader",
|
||||
truckType: TRUCK_TYPE,
|
||||
containerNumbers: numbers.slice(0, 3),
|
||||
},
|
||||
false,
|
||||
).then((res) => {
|
||||
expect(res.status, "3-container truck rejected").to.be.within(400, 422);
|
||||
expect(JSON.stringify(res.body)).to.match(/at most 2 containers/i);
|
||||
});
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it("HB then collects legally with two trucks of two", () => {
|
||||
withBooking("HB", (b) =>
|
||||
allocatedContainerNumbers(b.id).then((numbers) => {
|
||||
for (let i = 0; i < 2; i += 1) {
|
||||
apiPost(opsStaff, `/api/bookings/${b.id}/customer-trucks`, {
|
||||
truckPlateNumber: `E2E-HB-${i + 1}`,
|
||||
driverName: `E2E Driver B${i + 1}`,
|
||||
truckType: TRUCK_TYPE,
|
||||
containerNumbers: numbers.slice(i * 2, i * 2 + 2),
|
||||
})
|
||||
.its("status")
|
||||
.should("be.oneOf", [200, 201]);
|
||||
}
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it("a container already on a truck cannot be loaded onto a second one", () => {
|
||||
withBooking("HA", (b) =>
|
||||
allocatedContainerNumbers(b.id).then((numbers) => {
|
||||
// numbers[0] is already aboard HA's first truck.
|
||||
apiPost(
|
||||
opsStaff,
|
||||
`/api/bookings/${b.id}/customer-trucks`,
|
||||
{
|
||||
truckPlateNumber: "E2E-HA-DUP",
|
||||
driverName: "E2E Duplicate",
|
||||
truckType: TRUCK_TYPE,
|
||||
containerNumbers: [numbers[0]],
|
||||
},
|
||||
false,
|
||||
).then((res) => {
|
||||
expect(res.status, "duplicate container rejected").to.be.within(400, 422);
|
||||
expect(JSON.stringify(res.body)).to.match(/already loaded onto another truck/i);
|
||||
});
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it("a truck may not carry another booking's container", () => {
|
||||
// The picker only ever offers the booking's own containers; the API must
|
||||
// enforce the same thing.
|
||||
withBooking("HC", (hc) =>
|
||||
withBooking("HA", (ha) =>
|
||||
allocatedContainerNumbers(ha.id).then((foreign) =>
|
||||
apiPost(
|
||||
opsStaff,
|
||||
`/api/bookings/${hc.id}/customer-trucks`,
|
||||
{
|
||||
truckPlateNumber: "E2E-HC-FOREIGN",
|
||||
driverName: "E2E Wrong Cargo",
|
||||
truckType: TRUCK_TYPE,
|
||||
containerNumbers: [foreign[0]],
|
||||
},
|
||||
false,
|
||||
).then((res) => {
|
||||
expect(res.status, "foreign container rejected").to.be.within(400, 422);
|
||||
expect(JSON.stringify(res.body)).to.match(
|
||||
/not one of this booking|already loaded/i,
|
||||
);
|
||||
}),
|
||||
),
|
||||
),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
// S39 — three post-arrival paths off one train
|
||||
// ───────────────────────────────────────────────────────────────────────────
|
||||
|
||||
describe("G9·S39: last-mile, self-haul and yard pickup on one train", { retries: 0 }, () => {
|
||||
const DEPARTURE = departureAt(53);
|
||||
const BOOKING_DAY = eatDayStr(DEPARTURE);
|
||||
const SHAPES = {
|
||||
/** LA gets a delivery address → EDR last-mile. */
|
||||
LA: { twenty: 4, wagons: 2 },
|
||||
/** LB assigns its own trucks → self-haul. */
|
||||
LB: { twenty: 4, wagons: 2 },
|
||||
/** LC does neither → the customer collects from the yard. */
|
||||
LC: { twenty: 2, wagons: 1 },
|
||||
} as const;
|
||||
const ORDER = ["LA", "LB", "LC"] as const;
|
||||
|
||||
before(() => {
|
||||
cy.task("db:seedFile", "seed-import-corridor.sql");
|
||||
cy.task("db:seedFile", "seed-g1-train.sql");
|
||||
ORDER.forEach((suffix) =>
|
||||
seedImportContract({ suffix, reference: stampedRef(suffix) }),
|
||||
);
|
||||
});
|
||||
|
||||
it("three bookings ride the same train and arrive together", () => {
|
||||
ensureCorridorRoute();
|
||||
resetCorridorDay(DEPARTURE);
|
||||
configureAndOpenSchedule({ departure: DEPARTURE });
|
||||
|
||||
let isoSeed = 26_600;
|
||||
ORDER.forEach((suffix) => {
|
||||
bookContainers({
|
||||
suffix,
|
||||
runStamp: stamp,
|
||||
isoSeed,
|
||||
twenty: SHAPES[suffix].twenty,
|
||||
scheduledDate: BOOKING_DAY,
|
||||
});
|
||||
isoSeed += SHAPES[suffix].twenty;
|
||||
acceptOperation(suffix);
|
||||
});
|
||||
closeWindowAndRunBatch(DEPARTURE);
|
||||
ORDER.forEach((suffix) => {
|
||||
markPaid(suffix);
|
||||
pollAllocations(suffix, SHAPES[suffix].wagons);
|
||||
});
|
||||
withSchedule(DEPARTURE, (s) => endPaymentPhase(s.id));
|
||||
runToArrival(DEPARTURE, ORDER);
|
||||
});
|
||||
|
||||
it("LA is marked for last-mile by its delivery ADDRESS", () => {
|
||||
// The address alone is the signal — coordinates are optional and gate
|
||||
// nothing (mile-haulage.util.ts:20-31).
|
||||
withBooking("LA", (b) =>
|
||||
db(
|
||||
`UPDATE freight.bookings
|
||||
SET last_mile_delivery_address = $2,
|
||||
last_mile_delivery_lat = 9.0108,
|
||||
last_mile_delivery_lng = 38.7613
|
||||
WHERE id = $1`,
|
||||
[b.id, "E2E Warehouse, Addis Ababa"],
|
||||
),
|
||||
);
|
||||
withBooking("LA", (b) =>
|
||||
db<{ addr: string | null }>(
|
||||
`SELECT last_mile_delivery_address AS addr FROM freight.bookings WHERE id = $1`,
|
||||
[b.id],
|
||||
).then(({ rows }) =>
|
||||
expect(rows[0].addr, "LA carries a delivery address").to.be.a("string"),
|
||||
),
|
||||
);
|
||||
});
|
||||
|
||||
it("LB self-hauls — and the two paths are mutually exclusive", () => {
|
||||
withBooking("LB", (b) =>
|
||||
allocatedContainerNumbers(b.id).then((numbers) => {
|
||||
apiPost(opsStaff, `/api/bookings/${b.id}/customer-trucks`, {
|
||||
truckPlateNumber: "E2E-LB-1",
|
||||
driverName: "E2E Self Haul",
|
||||
truckType: TRUCK_TYPE,
|
||||
containerNumbers: numbers.slice(0, 2),
|
||||
})
|
||||
.its("status")
|
||||
.should("be.oneOf", [200, 201]);
|
||||
}),
|
||||
);
|
||||
|
||||
// A self-haul booking must not also be a last-mile one.
|
||||
withBooking("LB", (b) =>
|
||||
db<{ addr: string | null }>(
|
||||
`SELECT last_mile_delivery_address AS addr FROM freight.bookings WHERE id = $1`,
|
||||
[b.id],
|
||||
).then(({ rows }) =>
|
||||
expect(rows[0].addr, "LB has no delivery address").to.be.oneOf([null, ""]),
|
||||
),
|
||||
);
|
||||
});
|
||||
|
||||
it("LC does neither — no address, no trucks, collected from the yard", () => {
|
||||
withBooking("LC", (b) => {
|
||||
db<{ addr: string | null }>(
|
||||
`SELECT last_mile_delivery_address AS addr FROM freight.bookings WHERE id = $1`,
|
||||
[b.id],
|
||||
).then(({ rows }) =>
|
||||
expect(rows[0].addr, "no last-mile address").to.be.oneOf([null, ""]),
|
||||
);
|
||||
db<{ n: string }>(
|
||||
`SELECT count(*) AS n FROM freight.customer_truck_assignments
|
||||
WHERE booking_id = $1 AND deleted_at IS NULL`,
|
||||
[b.id],
|
||||
).then(({ rows }) => expect(Number(rows[0].n), "no trucks assigned").to.eq(0));
|
||||
});
|
||||
});
|
||||
|
||||
it("all three arrived, and none of the three paths blocked the others", () => {
|
||||
// The scenario's real claim: one train, three independent tails.
|
||||
ORDER.forEach((suffix) =>
|
||||
withBooking(suffix, (b) =>
|
||||
expect(b.status, `${suffix} arrived`).to.eq("ARRIVED"),
|
||||
),
|
||||
);
|
||||
withBooking("LB", (b) =>
|
||||
db<{ n: string }>(
|
||||
`SELECT count(*) AS n FROM freight.customer_truck_assignments
|
||||
WHERE booking_id = $1 AND deleted_at IS NULL`,
|
||||
[b.id],
|
||||
).then(({ rows }) =>
|
||||
expect(Number(rows[0].n), "LB's truck stands regardless of LA and LC").to.eq(1),
|
||||
),
|
||||
);
|
||||
});
|
||||
|
||||
it("a last-mile invoice is filed under the module's own source string", () => {
|
||||
// NOTE: last-mile billing writes the literal 'last_mile', while
|
||||
// Freight.InvoiceSource.LastMile is "lastmile" — the cast at
|
||||
// last-mile-invoice.service.ts:41 defeats the type check and the column is
|
||||
// an unconstrained varchar. Match what is WRITTEN, not the enum.
|
||||
withBooking("LA", (b) =>
|
||||
db<{ source: string }>(
|
||||
`SELECT DISTINCT source FROM freight.invoices
|
||||
WHERE source_id = $1 AND deleted_at IS NULL`,
|
||||
[b.id],
|
||||
).then(({ rows }) => {
|
||||
const sources = rows.map((r) => r.source);
|
||||
// The booking invoice always exists; a last-mile one only once the
|
||||
// delivery is actually raised, which is beyond this scenario's scope.
|
||||
expect(sources, "the booking's own invoice is present").to.include("booking");
|
||||
sources
|
||||
.filter((s) => s.includes("mile"))
|
||||
.forEach((s) =>
|
||||
expect(s, "last-mile rows use the underscored literal").to.eq("last_mile"),
|
||||
);
|
||||
}),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
export {};
|
||||
174
e2e/freight/cypress/fixtures/seed-g1-train.sql
Normal file
174
e2e/freight/cypress/fixtures/seed-g1-train.sql
Normal file
@@ -0,0 +1,174 @@
|
||||
-- Arrange-data for the GROUP 1 visual scenario specs (flows/g1_*.cy.ts).
|
||||
-- Run AFTER seed-import-corridor.sql (it provides the corridor yards, the
|
||||
-- 20FT/40FT container types + NW5 allow-list, the yard distances and the LIVE
|
||||
-- CONTAINER_IMPORT rates every booking here prices against). Idempotent.
|
||||
--
|
||||
-- WHY A BUILT TRAIN
|
||||
--
|
||||
-- The Group 1 scenarios are written against a 53-wagon train. A loco-pair
|
||||
-- schedule cannot hold that number: syncScheduleMaxWagons recomputes
|
||||
-- max_wagons as floor(locoLength / shortest active wagon length), which the
|
||||
-- corridor fixture deliberately pins at floor(760 / 13.966) = 54. A BUILT
|
||||
-- train is exempt — booking-batch.service.ts:4152 takes the physical consist
|
||||
-- count first and only falls back to the loco-derived figure:
|
||||
--
|
||||
-- const maxWagons = physicalWagons ?? capacityLimits(loco).base.wagons;
|
||||
--
|
||||
-- So 53 physically coupled wagons IS the capacity, and it survives the tick.
|
||||
-- This is also what makes the specs' visual config phase load-bearing rather
|
||||
-- than decorative: the consist staff marshal is the number the engine fills.
|
||||
--
|
||||
-- WEIGHT MUST NOT BIND IN GROUP 1
|
||||
--
|
||||
-- Group 1 tests slot arithmetic (fill, split, waitlist, priority). Weight is
|
||||
-- Group 2's axis and must stay slack here or a scenario would fail for the
|
||||
-- wrong reason. The locos below pull 9000T; a full 53-wagon board at the 10T
|
||||
-- default VGM the specs book weighs
|
||||
-- 53 × 22.4T tare + 106 × 10T cargo = 1187.2 + 1060 = 2247.2T — well under.
|
||||
-- Length: 53 × 13.966 = 740.2m under the 760m cap. Slots bind, nothing else.
|
||||
--
|
||||
-- DEDICATED CODES
|
||||
--
|
||||
-- LOCO-G1-*, TRN-G1-1, WGN-G1-* are used by NO other spec. seed-import-corridor
|
||||
-- re-parks loose NW5/CW4 stock between runs and sweeps whichever wagons sort
|
||||
-- last into other yards, so sharing the general pool would let a sibling spec
|
||||
-- steal this consist mid-run (see the header of seed-adjust-consist.sql for the
|
||||
-- same hazard). Coupled wagons (train_id set) are never swept.
|
||||
|
||||
-- 1. Locomotive pair at DJIB_PORT — the import corridor's origin yard, which a
|
||||
-- built-train schedule requires the train to be parked at. 9000T pull and 760m
|
||||
-- keep both non-slot axes slack (see header). No overage tolerance configured:
|
||||
-- Group 1 must never be rescued by tolerance, and Group 2 sets its own.
|
||||
INSERT INTO freight.locomotives
|
||||
(id, code, max_pull_weight_tons, max_train_length_meters,
|
||||
overage_tolerance_tons, current_yard_id)
|
||||
SELECT gen_random_uuid(), v.code, 9000, 760, 0, y.id
|
||||
FROM (VALUES ('LOCO-G1-A'), ('LOCO-G1-B')) AS v(code)
|
||||
JOIN freight.yards y ON y.code = 'DJIB_PORT'
|
||||
WHERE NOT EXISTS (SELECT 1 FROM freight.locomotives l WHERE l.code = v.code);
|
||||
|
||||
-- Re-assert limits every seed: a prior run's row may predate these numbers.
|
||||
UPDATE freight.locomotives
|
||||
SET max_pull_weight_tons = 9000, max_train_length_meters = 760,
|
||||
overage_tolerance_tons = 0,
|
||||
current_yard_id = (SELECT id FROM freight.yards WHERE code = 'DJIB_PORT')
|
||||
WHERE code IN ('LOCO-G1-A', 'LOCO-G1-B')
|
||||
AND (max_pull_weight_tons IS DISTINCT FROM 9000
|
||||
OR max_train_length_meters IS DISTINCT FROM 760
|
||||
OR overage_tolerance_tons IS DISTINCT FROM 0);
|
||||
|
||||
-- 2. The built train, parked at the corridor origin.
|
||||
INSERT INTO freight.trains
|
||||
(id, code, train_name, capacity_tons, current_yard_id,
|
||||
import_train_number, export_train_number)
|
||||
SELECT gen_random_uuid(), 'TRN-G1-1', 'E2E Group-1 Container Carrier', 3500, y.id,
|
||||
'9202', '9201'
|
||||
FROM freight.yards y
|
||||
WHERE y.code = 'DJIB_PORT'
|
||||
AND NOT EXISTS (SELECT 1 FROM freight.trains t WHERE t.code = 'TRN-G1-1');
|
||||
|
||||
-- 3. Couple the locomotive pair to the train.
|
||||
INSERT INTO freight.train_locomotives (id, train_id, locomotive_id, sequence_no)
|
||||
SELECT gen_random_uuid(), t.id, l.id, v.seq
|
||||
FROM (VALUES ('LOCO-G1-A', 0), ('LOCO-G1-B', 1)) AS v(loco_code, seq)
|
||||
JOIN freight.trains t ON t.code = 'TRN-G1-1'
|
||||
JOIN freight.locomotives l ON l.code = v.loco_code
|
||||
WHERE NOT EXISTS (
|
||||
SELECT 1 FROM freight.train_locomotives tl
|
||||
WHERE tl.train_id = t.id AND tl.locomotive_id = l.id
|
||||
);
|
||||
|
||||
-- 4. Fifty-three dedicated NW5 flat wagons at DJIB_PORT. NW5 is the type the
|
||||
-- 20FT/40FT container types are allow-listed onto (seed-import-corridor 2b),
|
||||
-- so a container booking can actually be allocated onto them.
|
||||
INSERT INTO freight.wagons (id, wagon_number, wagon_type_id, current_yard_id)
|
||||
SELECT gen_random_uuid(), 'WGN-G1-' || lpad(g::text, 2, '0'), wt.id, y.id
|
||||
FROM generate_series(1, 53) AS g
|
||||
JOIN freight.wagon_types wt ON wt.code = 'NW5'
|
||||
JOIN freight.yards y ON y.code = 'DJIB_PORT'
|
||||
WHERE NOT EXISTS (
|
||||
SELECT 1 FROM freight.wagons w
|
||||
WHERE w.wagon_number = 'WGN-G1-' || lpad(g::text, 2, '0')
|
||||
);
|
||||
|
||||
-- Couple all 53 onto the train, in order. Unconditionally re-asserted: a prior
|
||||
-- run's adjust-consist or an allocation left mid-flight could have detached one,
|
||||
-- and a 52-wagon consist would silently shift every scenario's arithmetic by a
|
||||
-- slot (the exact-fit cases in S1/S2 would stop being exact).
|
||||
UPDATE freight.wagons w
|
||||
SET train_id = t.id,
|
||||
sequence_number = g.seq,
|
||||
status = 'ASSIGNED',
|
||||
current_yard_id = t.current_yard_id
|
||||
FROM freight.trains t,
|
||||
LATERAL (
|
||||
SELECT ('WGN-G1-' || lpad(s::text, 2, '0')) AS num, s AS seq
|
||||
FROM generate_series(1, 53) AS s
|
||||
) g
|
||||
WHERE t.code = 'TRN-G1-1'
|
||||
AND w.wagon_number = g.num
|
||||
AND (w.train_id IS DISTINCT FROM t.id
|
||||
OR w.sequence_number IS DISTINCT FROM g.seq
|
||||
OR w.status IS DISTINCT FROM 'ASSIGNED');
|
||||
|
||||
-- 5. A second built train for the multi-schedule scenarios (Group 4 reuses this
|
||||
-- fixture; Group 1 never schedules it). Same 53-wagon shape so "two identical
|
||||
-- trains on one day" is a true statement about capacity.
|
||||
INSERT INTO freight.locomotives
|
||||
(id, code, max_pull_weight_tons, max_train_length_meters,
|
||||
overage_tolerance_tons, current_yard_id)
|
||||
SELECT gen_random_uuid(), v.code, 9000, 760, 0, y.id
|
||||
FROM (VALUES ('LOCO-G1-C'), ('LOCO-G1-D')) AS v(code)
|
||||
JOIN freight.yards y ON y.code = 'DJIB_PORT'
|
||||
WHERE NOT EXISTS (SELECT 1 FROM freight.locomotives l WHERE l.code = v.code);
|
||||
|
||||
INSERT INTO freight.trains
|
||||
(id, code, train_name, capacity_tons, current_yard_id,
|
||||
import_train_number, export_train_number)
|
||||
SELECT gen_random_uuid(), 'TRN-G1-2', 'E2E Group-1 Container Carrier II', 3500, y.id,
|
||||
'9204', '9203'
|
||||
FROM freight.yards y
|
||||
WHERE y.code = 'DJIB_PORT'
|
||||
AND NOT EXISTS (SELECT 1 FROM freight.trains t WHERE t.code = 'TRN-G1-2');
|
||||
|
||||
INSERT INTO freight.train_locomotives (id, train_id, locomotive_id, sequence_no)
|
||||
SELECT gen_random_uuid(), t.id, l.id, v.seq
|
||||
FROM (VALUES ('LOCO-G1-C', 0), ('LOCO-G1-D', 1)) AS v(loco_code, seq)
|
||||
JOIN freight.trains t ON t.code = 'TRN-G1-2'
|
||||
JOIN freight.locomotives l ON l.code = v.loco_code
|
||||
WHERE NOT EXISTS (
|
||||
SELECT 1 FROM freight.train_locomotives tl
|
||||
WHERE tl.train_id = t.id AND tl.locomotive_id = l.id
|
||||
);
|
||||
|
||||
INSERT INTO freight.wagons (id, wagon_number, wagon_type_id, current_yard_id)
|
||||
SELECT gen_random_uuid(), 'WGN-G2-' || lpad(g::text, 2, '0'), wt.id, y.id
|
||||
FROM generate_series(1, 53) AS g
|
||||
JOIN freight.wagon_types wt ON wt.code = 'NW5'
|
||||
JOIN freight.yards y ON y.code = 'DJIB_PORT'
|
||||
WHERE NOT EXISTS (
|
||||
SELECT 1 FROM freight.wagons w
|
||||
WHERE w.wagon_number = 'WGN-G2-' || lpad(g::text, 2, '0')
|
||||
);
|
||||
|
||||
UPDATE freight.wagons w
|
||||
SET train_id = t.id,
|
||||
sequence_number = g.seq,
|
||||
status = 'ASSIGNED',
|
||||
current_yard_id = t.current_yard_id
|
||||
FROM freight.trains t,
|
||||
LATERAL (
|
||||
SELECT ('WGN-G2-' || lpad(s::text, 2, '0')) AS num, s AS seq
|
||||
FROM generate_series(1, 53) AS s
|
||||
) g
|
||||
WHERE t.code = 'TRN-G1-2'
|
||||
AND w.wagon_number = g.num
|
||||
AND (w.train_id IS DISTINCT FROM t.id
|
||||
OR w.sequence_number IS DISTINCT FROM g.seq
|
||||
OR w.status IS DISTINCT FROM 'ASSIGNED');
|
||||
|
||||
-- NOTE on S7's government queue-jump: nothing is needed here. The bonus
|
||||
-- (GOVERNMENT_PRIORITY_BONUS = 50_000, rule-engine.service.ts:258) keys off
|
||||
-- `contracts.is_government` / `government_institution`, which the booking
|
||||
-- inherits (contract-booking.service.ts:268) — so it is set per contract by
|
||||
-- seedImportContract({ government: true }), not by fleet arrange-data.
|
||||
132
e2e/freight/cypress/fixtures/seed-g2-weight.sql
Normal file
132
e2e/freight/cypress/fixtures/seed-g2-weight.sql
Normal file
@@ -0,0 +1,132 @@
|
||||
-- Arrange-data for the GROUP 2 weight/tolerance scenarios (flows/g2_weight.cy.ts).
|
||||
-- Run AFTER seed-import-corridor.sql. Idempotent.
|
||||
--
|
||||
-- Group 2 is the only group where WEIGHT binds before slots. Group 1's train
|
||||
-- (TRN-G1-1) deliberately keeps every non-slot axis slack; this one does the
|
||||
-- opposite, so the two must never share rolling stock.
|
||||
--
|
||||
-- THE ARITHMETIC (all from train-capacity.util.ts)
|
||||
--
|
||||
-- The weight axis is GROSS — a locomotive hauls the wagon as well as its
|
||||
-- cargo (`grossWagonWeightTons` = tare + cargo). NW5 tare is 22.4T, and two
|
||||
-- 20ft containers ride one NW5. So with a heavy VGM of 28T per container:
|
||||
--
|
||||
-- wagon gross = 2 × 28 + 22.4 = 78.4T ← S9's number exactly
|
||||
--
|
||||
-- S9 base pull 3500T: 35 wagons × 78.4 = 2744.0T ✔ fits
|
||||
-- 45 wagons × 78.4 = 3528.0T ✘ over base
|
||||
-- → C is blocked on WEIGHT while 18 slots still sit empty.
|
||||
--
|
||||
-- S10 tolerance 90T → cap 3590T: 3528 ≤ 3590, so C is admitted WHOLE.
|
||||
-- Tolerance is spendable ONLY to admit a booking whole.
|
||||
--
|
||||
-- S11 after 2744T used, base room = 3500 − 2744 = 756T.
|
||||
-- 756 / 78.4 = 9.64 → a split may size at most 9 wagons (705.6T).
|
||||
-- It may NEVER reach 10 by dipping into the 90T tolerance, because
|
||||
-- sizePartialOfferWagons budgets against BASE only
|
||||
-- (train-capacity.util.ts:58, booking-batch.service.ts:4109).
|
||||
--
|
||||
-- S12 light cargo (12T/container): wagon gross = 2 × 12 + 22.4 = 46.4T.
|
||||
-- 53 × 46.4 = 2459.2T — only 70% of base. SLOTS bind, not weight.
|
||||
--
|
||||
-- TWO LOCOMOTIVE PAIRS, ONE TRAIN EACH
|
||||
--
|
||||
-- Pull weight ADDS UP across a set but length takes the MINIMUM
|
||||
-- (combinedLocomotiveLimits, train-capacity.util.ts:358), so a pair of 1750T
|
||||
-- locos gives exactly the 3500T base the scenarios assume. Weight tolerance
|
||||
-- adds up too — hence 45T each for the 90T set.
|
||||
--
|
||||
-- TRN-G2-BASE LOCO-G2-A/B 1750T each, tolerance 0 → 3500T base, no slack
|
||||
-- TRN-G2-TOL LOCO-G2-C/D 1750T each, tolerance 45T → 3500T base + 90T
|
||||
--
|
||||
-- Both carry 53 NW5 wagons so the SLOT axis is identical to Group 1 and any
|
||||
-- difference in outcome is attributable to weight alone.
|
||||
|
||||
-- 1. Locomotives. Length 760m keeps the length axis slack (53 × 13.966 =
|
||||
-- 740.2m < 760m), so only weight and slots can ever bind here.
|
||||
INSERT INTO freight.locomotives
|
||||
(id, code, max_pull_weight_tons, max_train_length_meters,
|
||||
overage_tolerance_tons, overage_tolerance_meters, current_yard_id)
|
||||
SELECT gen_random_uuid(), v.code, 1750, 760, v.tol, 0, y.id
|
||||
FROM (VALUES
|
||||
('LOCO-G2-A', 0), ('LOCO-G2-B', 0),
|
||||
('LOCO-G2-C', 45), ('LOCO-G2-D', 45)
|
||||
) AS v(code, tol)
|
||||
JOIN freight.yards y ON y.code = 'DJIB_PORT'
|
||||
WHERE NOT EXISTS (SELECT 1 FROM freight.locomotives l WHERE l.code = v.code);
|
||||
|
||||
-- Re-assert every seed: a prior run's row may predate these numbers, and the
|
||||
-- whole group's arithmetic depends on them being exact.
|
||||
UPDATE freight.locomotives l
|
||||
SET max_pull_weight_tons = 1750,
|
||||
max_train_length_meters = 760,
|
||||
overage_tolerance_tons = v.tol,
|
||||
overage_tolerance_meters = 0,
|
||||
current_yard_id = (SELECT id FROM freight.yards WHERE code = 'DJIB_PORT')
|
||||
FROM (VALUES
|
||||
('LOCO-G2-A', 0), ('LOCO-G2-B', 0),
|
||||
('LOCO-G2-C', 45), ('LOCO-G2-D', 45)
|
||||
) AS v(code, tol)
|
||||
WHERE l.code = v.code
|
||||
AND (l.max_pull_weight_tons IS DISTINCT FROM 1750
|
||||
OR l.max_train_length_meters IS DISTINCT FROM 760
|
||||
OR l.overage_tolerance_tons IS DISTINCT FROM v.tol);
|
||||
|
||||
-- 2. The two trains at the corridor origin.
|
||||
INSERT INTO freight.trains
|
||||
(id, code, train_name, capacity_tons, current_yard_id,
|
||||
import_train_number, export_train_number)
|
||||
SELECT gen_random_uuid(), v.code, v.name, 3500, y.id, v.imp, v.exp
|
||||
FROM (VALUES
|
||||
('TRN-G2-BASE', 'E2E Group-2 Base-Weight Carrier', '9302', '9301'),
|
||||
('TRN-G2-TOL', 'E2E Group-2 Tolerance Carrier', '9304', '9303')
|
||||
) AS v(code, name, imp, exp)
|
||||
JOIN freight.yards y ON y.code = 'DJIB_PORT'
|
||||
WHERE NOT EXISTS (SELECT 1 FROM freight.trains t WHERE t.code = v.code);
|
||||
|
||||
-- 3. Couple each locomotive pair to its train.
|
||||
INSERT INTO freight.train_locomotives (id, train_id, locomotive_id, sequence_no)
|
||||
SELECT gen_random_uuid(), t.id, l.id, v.seq
|
||||
FROM (VALUES
|
||||
('TRN-G2-BASE', 'LOCO-G2-A', 0), ('TRN-G2-BASE', 'LOCO-G2-B', 1),
|
||||
('TRN-G2-TOL', 'LOCO-G2-C', 0), ('TRN-G2-TOL', 'LOCO-G2-D', 1)
|
||||
) AS v(train_code, loco_code, seq)
|
||||
JOIN freight.trains t ON t.code = v.train_code
|
||||
JOIN freight.locomotives l ON l.code = v.loco_code
|
||||
WHERE NOT EXISTS (
|
||||
SELECT 1 FROM freight.train_locomotives tl
|
||||
WHERE tl.train_id = t.id AND tl.locomotive_id = l.id
|
||||
);
|
||||
|
||||
-- 4. 53 dedicated NW5 wagons per train (WGN-G2B-*, WGN-G2T-*). Same slot count
|
||||
-- as Group 1 on purpose — see the header.
|
||||
INSERT INTO freight.wagons (id, wagon_number, wagon_type_id, current_yard_id)
|
||||
SELECT gen_random_uuid(), v.prefix || lpad(g::text, 2, '0'), wt.id, y.id
|
||||
FROM generate_series(1, 53) AS g
|
||||
CROSS JOIN (VALUES ('WGN-G2B-'), ('WGN-G2T-')) AS v(prefix)
|
||||
JOIN freight.wagon_types wt ON wt.code = 'NW5'
|
||||
JOIN freight.yards y ON y.code = 'DJIB_PORT'
|
||||
WHERE NOT EXISTS (
|
||||
SELECT 1 FROM freight.wagons w
|
||||
WHERE w.wagon_number = v.prefix || lpad(g::text, 2, '0')
|
||||
);
|
||||
|
||||
-- Couple them, unconditionally re-asserted: a 52-wagon consist would shift the
|
||||
-- weight-vs-slot boundary the whole group is built to probe.
|
||||
UPDATE freight.wagons w
|
||||
SET train_id = t.id,
|
||||
sequence_number = g.seq,
|
||||
status = 'ASSIGNED',
|
||||
current_yard_id = t.current_yard_id
|
||||
FROM freight.trains t,
|
||||
LATERAL (
|
||||
SELECT s AS seq,
|
||||
CASE WHEN t.code = 'TRN-G2-BASE' THEN 'WGN-G2B-' ELSE 'WGN-G2T-' END
|
||||
|| lpad(s::text, 2, '0') AS num
|
||||
FROM generate_series(1, 53) AS s
|
||||
) g
|
||||
WHERE t.code IN ('TRN-G2-BASE', 'TRN-G2-TOL')
|
||||
AND w.wagon_number = g.num
|
||||
AND (w.train_id IS DISTINCT FROM t.id
|
||||
OR w.sequence_number IS DISTINCT FROM g.seq
|
||||
OR w.status IS DISTINCT FROM 'ASSIGNED');
|
||||
Reference in New Issue
Block a user