Adding stop based booking configuration

apps/edr-passenger-api/test/checkin-cutoff.e2e-spec.ts

@@ -0,0 +1,203 @@
+/**
+ * Per-station check-in cutoff — proves booking closure is now based on each stop's own
+ * ESTIMATED ARRIVAL time (computed from RouteStop.travelMinutesToStop), not the schedule's
+ * overall departure. The regression this guards: before this change, all stops effectively
+ * shared one cutoff basis, so a later station could be wrongly blocked (or an earlier one
+ * wrongly left open) together with the rest of the route.
+ *
+ * Uses the slim harness (SchedulesService, real Nest DI) for schedule creation — this exercises
+ * the actual cumulative travel-time interpolation in SchedulesService.createSchedule. SeatsService
+ * and TasksService are NOT in the slim harness's DOMAIN_MODULES (they pull in NotificationsModule
+ * → RabbitMQ, which the slim harness deliberately avoids — see test/setup/slim-app.ts), so they're
+ * instantiated directly with a real Prisma + stubbed collaborators, mirroring the Tier-2 pattern in
+ * money-integrity.e2e-spec.ts.
+ */
+import { SchedulesService } from "../src/modules/schedules/schedules.service";
+import { SeatsService } from "../src/modules/seats/seats.service";
+import { TasksService } from "../src/modules/tasks/tasks.service";
+import { SystemConfigService } from "../src/modules/system-config/system-config.service";
+import { createServiceHarness, ServiceHarness } from "./setup/slim-app";
+import { IDS, DISTANCE, resetAndSeedCore } from "./fixtures/seed-core";
+
+/** A Proxy whose every property is an async no-op — satisfies unused collaborator method calls. */
+function asyncStub(): any {
+  return new Proxy({}, { get: () => async () => undefined });
+}
+
+/** Creates a fresh Train + TrainSchedule on the seed-core route via the real interpolation logic. */
+async function createTestSchedule(
+  harness: ServiceHarness,
+  schedules: SchedulesService,
+  opts: { trainNumber: string; departureAt: Date; arrivalAt: Date },
+) {
+  const train = await harness.prisma.train.create({
+    data: { number: opts.trainNumber, name: `Test ${opts.trainNumber}` },
+  });
+  const schedule = await schedules.createSchedule({
+    trainId: train.id,
+    routeId: IDS.route,
+    departureAt: opts.departureAt.toISOString(),
+    arrivalAt: opts.arrivalAt.toISOString(),
+  } as any);
+
+  // Give the schedule a bookable coach so holdSeats has real seats to work with.
+  const coach = await harness.prisma.coach.create({
+    data: { coachTypeId: IDS.coachType, number: `${opts.trainNumber}-C1`, capacity: 4, sequence: 1, status: "ACTIVE" },
+  });
+  await harness.prisma.coachAssignment.create({
+    data: { scheduleId: schedule.id, coachId: coach.id, positionNumber: 1, isOperational: true },
+  });
+  const seats = await Promise.all(
+    ["1A", "1B", "1C", "1D"].map((seatNumber, i) =>
+      harness.prisma.seat.create({
+        data: { coachId: coach.id, seatNumber, row: 1, col: seatNumber.slice(-1), isWindow: i === 0, isAisle: i === 1 },
+      }),
+    ),
+  );
+
+  return { schedule, seats };
+}
+
+describe("Check-in cutoff — arrival-time basis, per-station independence", () => {
+  let harness: ServiceHarness;
+  let schedulesService: SchedulesService;
+  let seatsService: SeatsService;
+  let tasksService: TasksService;
+
+  beforeAll(async () => {
+    harness = await createServiceHarness();
+    schedulesService = await harness.moduleRef.resolve(SchedulesService);
+    const systemConfig = new SystemConfigService(harness.prisma as any);
+    seatsService = new SeatsService(harness.prisma as any, asyncStub(), systemConfig, asyncStub(), asyncStub());
+    tasksService = new TasksService(harness.prisma as any, asyncStub(), asyncStub());
+  });
+
+  afterAll(async () => {
+    await harness?.close();
+  });
+
+  it("a later station remains independently bookable after an earlier station's cutoff has passed", async () => {
+    await resetAndSeedCore(harness.prisma);
+
+    // dep only 5 min out (createSchedule requires a future departureAt). Route-level default
+    // checkinMinutesBefore is 30 (schema default, unset here), so A's cutoff (dep - 30min) is
+    // already ~25 min in the past by the time this runs — but B, with a 60-min travel time from
+    // A, has an arrival far enough out (dep + 60min) that its own cutoff (arrival - 30min) is
+    // still ~35 min in the future.
+    const dep = new Date(Date.now() + 5 * 60_000);
+    const arr = new Date(dep.getTime() + 100 * 60_000); // A->B 60min + B->C 40min
+    await harness.prisma.routeStop.update({
+      where: { routeId_sequence: { routeId: IDS.route, sequence: 2 } },
+      data: { travelMinutesToStop: 60 },
+    });
+    await harness.prisma.routeStop.update({
+      where: { routeId_sequence: { routeId: IDS.route, sequence: 3 } },
+      data: { travelMinutesToStop: 40 },
+    });
+
+    const { schedule, seats } = await createTestSchedule(harness, schedulesService, {
+      trainNumber: `CUTOFF-A-${Date.now()}`,
+      departureAt: dep,
+      arrivalAt: arr,
+    });
+
+    await expect(
+      seatsService.holdSeats({
+        scheduleId: schedule.id,
+        originStationId: IDS.stationA,
+        destinationStationId: IDS.stationB,
+        passengers: [{ passengerId: "11111111-1111-4111-8111-111111111111", seatId: seats[0].id }],
+      } as any),
+    ).rejects.toThrow(/cannot be held within/i);
+
+    const held = await seatsService.holdSeats({
+      scheduleId: schedule.id,
+      originStationId: IDS.stationB,
+      destinationStationId: IDS.stationC,
+      passengers: [{ passengerId: "22222222-2222-4222-8222-222222222222", seatId: seats[1].id }],
+    } as any);
+    expect(held).toBeTruthy();
+  });
+
+  it("a stop-level checkinMinutesBefore override wins over the route-level default", async () => {
+    // Override B with a LARGE cutoff (90 min) — under the route default (30 min) this exact
+    // schedule's B segment would still be OPEN (see previous test), so a rejection here proves
+    // the stop-level override, not the default, is what's actually being applied.
+    await resetAndSeedCore(harness.prisma, { B: { checkinMinutesBefore: 90 } });
+    await harness.prisma.routeStop.update({
+      where: { routeId_sequence: { routeId: IDS.route, sequence: 2 } },
+      data: { travelMinutesToStop: 60 },
+    });
+
+    const dep = new Date(Date.now() + 5 * 60_000);
+    const arr = new Date(dep.getTime() + 100 * 60_000);
+    const { schedule, seats } = await createTestSchedule(harness, schedulesService, {
+      trainNumber: `CUTOFF-B-${Date.now()}`,
+      departureAt: dep,
+      arrivalAt: arr,
+    });
+
+    await expect(
+      seatsService.holdSeats({
+        scheduleId: schedule.id,
+        originStationId: IDS.stationB,
+        destinationStationId: IDS.stationC,
+        passengers: [{ passengerId: "33333333-3333-4333-8333-333333333333", seatId: seats[0].id }],
+      } as any),
+    ).rejects.toThrow(/cannot be held within 90 minute/i);
+  });
+
+  it("syncScheduleStatuses closes only the specific stops past their own arrival-based cutoff", async () => {
+    await resetAndSeedCore(harness.prisma);
+    await harness.prisma.routeStop.update({
+      where: { routeId_sequence: { routeId: IDS.route, sequence: 2 } },
+      data: { travelMinutesToStop: 60 },
+    });
+    await harness.prisma.routeStop.update({
+      where: { routeId_sequence: { routeId: IDS.route, sequence: 3 } },
+      data: { travelMinutesToStop: 40 },
+    });
+
+    const dep = new Date(Date.now() + 5 * 60_000);
+    const arr = new Date(dep.getTime() + 100 * 60_000);
+    const { schedule } = await createTestSchedule(harness, schedulesService, {
+      trainNumber: `CUTOFF-C-${Date.now()}`,
+      departureAt: dep,
+      arrivalAt: arr,
+    });
+
+    await tasksService.syncScheduleStatuses();
+
+    const stopTimes = await harness.prisma.tripStopTime.findMany({
+      where: { scheduleId: schedule.id },
+      orderBy: { sequence: "asc" },
+    });
+    const byStation = Object.fromEntries(stopTimes.map((s) => [s.stationId, s.status]));
+    expect(byStation[IDS.stationA]).toBe("CHECKIN_CLOSED");
+    expect(byStation[IDS.stationB]).toBe("OPEN");
+    expect(byStation[IDS.stationC]).toBe("OPEN");
+  });
+
+  it("a stop missing travelMinutesToStop falls back to distance interpolation without failing schedule creation", async () => {
+    await resetAndSeedCore(harness.prisma); // no travelMinutesToStop set on any stop
+
+    const dep = new Date(Date.now() + 60 * 60_000);
+    const arr = new Date(dep.getTime() + 240 * 60_000); // 4h, matches seed-ui's convention
+    const { schedule } = await createTestSchedule(harness, schedulesService, {
+      trainNumber: `CUTOFF-D-${Date.now()}`,
+      departureAt: dep,
+      arrivalAt: arr,
+    });
+
+    const stopTimes = await harness.prisma.tripStopTime.findMany({
+      where: { scheduleId: schedule.id },
+      orderBy: { sequence: "asc" },
+    });
+    const totalDuration = arr.getTime() - dep.getTime();
+    const bProgress = DISTANCE.B / DISTANCE.C;
+    const expectedBArrival = new Date(dep.getTime() + totalDuration * bProgress);
+
+    const bStop = stopTimes.find((s) => s.stationId === IDS.stationB)!;
+    expect(bStop.plannedArrivalAt?.getTime()).toBe(expectedBArrival.getTime());
+  });
+});