fix: start time based on interval check

Author: joonatank

apps/ui/components/reservation-unit/utils.test.ts

@@ -126,7 +126,7 @@ function constructDate(d: Date, hours: number, minutes: number) {
 describe("getNextAvailableTime", () => {
   beforeAll(() => {
     jest.useFakeTimers({
-      doNotFake: ['performance'],
+      doNotFake: ["performance"],
       // There is some weird time zone issues (this seems to work)
       now: new Date(2024, 0, 1, 9, 0, 0),
     });
@@ -153,14 +153,21 @@ describe("getNextAvailableTime", () => {
     ]);
   });
 
-  function mockOpenTimes(start: Date, days: number, data?: Array<{ start: Date; end: Date }>) {
+  function mockOpenTimes(
+    start: Date,
+    days: number,
+    data?: Array<{ start: Date; end: Date }>
+  ) {
     for (let i = 0; i < days; i++) {
-      reservableTimes.set(dateToKey(addDays(start, i)), data ?? [
-        {
-          start: constructDate(addDays(start, i), 10, 0),
-          end: constructDate(addDays(start, i), 15, 0),
-        },
-      ]);
+      reservableTimes.set(
+        dateToKey(addDays(start, i)),
+        data ?? [
+          {
+            start: constructDate(addDays(start, i), 10, 0),
+            end: constructDate(addDays(start, i), 15, 0),
+          },
+        ]
+      );
     }
   }
 
@@ -169,7 +176,7 @@ describe("getNextAvailableTime", () => {
     duration,
     reservationsMinDaysBefore,
     reservationsMaxDaysBefore,
-    activeApplicationRounds
+    activeApplicationRounds,
   }: {
     start: Date;
     duration: number;
@@ -296,7 +303,7 @@ describe("getNextAvailableTime", () => {
   describe("reservationsMinDaysBefore check", () => {
     test("finds the next available time a week from now", () => {
       const today = new Date();
-      mockOpenTimes(today, 2*7);
+      mockOpenTimes(today, 2 * 7);
       const input = createInput({
         start: today,
         duration: 60,
@@ -340,10 +347,12 @@ describe("getNextAvailableTime", () => {
       const today = new Date();
       mockOpenTimes(today, 30);
       const end = addDays(today, 7);
-      const activeApplicationRounds: RoundPeriod[] = [{
-        reservationPeriodBegin: addDays(today, -7).toISOString(),
-        reservationPeriodEnd: end.toISOString(),
-      }];
+      const activeApplicationRounds: RoundPeriod[] = [
+        {
+          reservationPeriodBegin: addDays(today, -7).toISOString(),
+          reservationPeriodEnd: end.toISOString(),
+        },
+      ];
       const input = createInput({
         start: today,
         duration: 60,
@@ -353,7 +362,7 @@ describe("getNextAvailableTime", () => {
       expect(val).toBeInstanceOf(Date);
       expect(val!.getDate()).toBe(addDays(end, 1).getDate());
       expect(val!.getHours()).toBe(10);
-    })
+    });
 
     test("multiple overlapping activeApplicationRounds", () => {
       const today = new Date();
@@ -378,7 +387,7 @@ describe("getNextAvailableTime", () => {
       expect(val).toBeInstanceOf(Date);
       expect(val!.getDate()).toBe(addDays(end, 3).getDate());
       expect(val!.getHours()).toBe(10);
-    })
+    });
 
     test("finds a time between non-overlapping activeApplicationRounds", () => {
       const today = new Date();
@@ -409,27 +418,31 @@ describe("getNextAvailableTime", () => {
       const today = new Date();
       mockOpenTimes(today, 30);
       const end = addDays(today, 31);
-      const activeApplicationRounds: RoundPeriod[] = [{
-        reservationPeriodBegin: addDays(today, -7).toISOString(),
-        reservationPeriodEnd: end.toISOString(),
-      }];
+      const activeApplicationRounds: RoundPeriod[] = [
+        {
+          reservationPeriodBegin: addDays(today, -7).toISOString(),
+          reservationPeriodEnd: end.toISOString(),
+        },
+      ];
       const input = createInput({
         start: addDays(end, 1),
         duration: 60,
         activeApplicationRounds,
       });
       const val = getNextAvailableTime(input);
       expect(val).toBeNull();
-    })
+    });
 
     // TODO add more tests for application round
     // block 12 months using activeApplicationRounds, measure the time it takes
     test("performance: finds the next available time after a long application round", () => {
       mockOpenTimes(new Date(), 2 * 365);
-      const activeApplicationRounds: RoundPeriod[] = [{
-        reservationPeriodBegin: new Date().toISOString(),
-        reservationPeriodEnd: addDays(new Date(), 365).toISOString(),
-      }];
+      const activeApplicationRounds: RoundPeriod[] = [
+        {
+          reservationPeriodBegin: new Date().toISOString(),
+          reservationPeriodEnd: addDays(new Date(), 365).toISOString(),
+        },
+      ];
       const today = new Date();
       const input = createInput({
         start: today,
@@ -442,7 +455,7 @@ describe("getNextAvailableTime", () => {
       const perfTime = perfEnd - perfStart;
       expect(val).toBeInstanceOf(Date);
       expect(perfTime).toBeLessThan(100);
-    })
+    });
   });
 });
 /* eslint-enable @typescript-eslint/no-non-null-assertion */

apps/ui/components/reservation-unit/utils.ts

@@ -1,4 +1,11 @@
-import { addDays, addMinutes, isAfter, isBefore, set, startOfDay } from "date-fns";
+import {
+  addDays,
+  addMinutes,
+  isAfter,
+  isBefore,
+  set,
+  startOfDay,
+} from "date-fns";
 import type {
   ReservationUnitNode,
   ReservationUnitPageQuery,
@@ -119,7 +126,9 @@ export function getNextAvailableTime(props: AvailableTimesProps): Date | null {
   const endDay = possibleEndDay ? addDays(possibleEndDay, 1) : undefined;
   // NOTE there is still a case where application rounds have a hole but there are no reservable times
   // this is not a real use case but technically possible
-  const openAfterRound: Date | undefined = props.activeApplicationRounds.reduce<Date | undefined>((acc, round) => {
+  const openAfterRound: Date | undefined = props.activeApplicationRounds.reduce<
+    Date | undefined
+  >((acc, round) => {
     if (round.reservationPeriodEnd == null) {
       return acc;
     }

apps/ui/modules/__tests__/reservable.test.ts

@@ -12,6 +12,7 @@ import {
   generateReservableMap,
   isRangeReservable,
   getDayIntervals,
+  isStartTimeValid,
 } from "../reservable";
 import {
   type IsReservableFieldsFragment,
@@ -237,7 +238,67 @@ describe("generateReservableMap", () => {
   });
 });
 
+describe("isStartTimeValid", () => {
+  function mockReservableTimes(): ReservableMap {
+    const map: ReservableMap = new Map();
+    for (let i = 0; i < 30; i++) {
+      const date = addDays(startOfToday(), i);
+      const key = format(date, "yyyy-MM-dd");
+      // TODO need to have holes in this
+      const value = [{ start: startOfDay(date), end: endOfDay(date) }];
+      map.set(key, value);
+    }
+    return map;
+  }
+  // TODO fuzzy this
+  test("YES for 15 min intervals", () => {
+    const date = startOfDay(addDays(new Date(), 1));
+    const start = addHours(date, 9);
+    const interval = ReservationStartInterval.Interval_15Mins;
+    const reservableTimes = mockReservableTimes();
+    expect(isStartTimeValid(start, reservableTimes, interval)).toBe(true);
+  });
+  // TODO fuzzy
+  test("YES for 30 min intervals", () => {
+    const date = startOfDay(addDays(new Date(), 1));
+    const start = addHours(date, 9);
+    const interval = ReservationStartInterval.Interval_30Mins;
+    const reservableTimes = mockReservableTimes();
+    expect(isStartTimeValid(start, reservableTimes, interval)).toBe(true);
+  });
+  test("YES for 60 min intervals", () => {
+    const date = startOfDay(addDays(new Date(), 1));
+    const start = addHours(date, 9);
+    const interval = ReservationStartInterval.Interval_60Mins;
+    const reservableTimes = mockReservableTimes();
+    expect(isStartTimeValid(start, reservableTimes, interval)).toBe(true);
+  });
+  test("NO for 60 min intervals", () => {
+    const date = startOfDay(addDays(new Date(), 1));
+    const start = addHours(date, 9.5);
+    const interval = ReservationStartInterval.Interval_60Mins;
+    const reservableTimes = mockReservableTimes();
+    expect(isStartTimeValid(start, reservableTimes, interval)).toBe(false);
+  });
+  test("YES for 120 min intervals", () => {
+    const date = startOfDay(addDays(new Date(), 1));
+    const start = addHours(date, 10);
+    const interval = ReservationStartInterval.Interval_120Mins;
+    const reservableTimes = mockReservableTimes();
+    expect(isStartTimeValid(start, reservableTimes, interval)).toBe(true);
+  });
+  test("NO for 120 min intervals", () => {
+    const date = startOfDay(addDays(new Date(), 1));
+    const start = addHours(date, 9);
+    const interval = ReservationStartInterval.Interval_120Mins;
+    const reservableTimes = mockReservableTimes();
+    expect(isStartTimeValid(start, reservableTimes, interval)).toBe(false);
+  });
+});
+
 describe("isRangeReservable", () => {
+  // TODO mock time
+
   // one month of reservable times
   function mockReservableTimes(): ReservableMap {
     const map: ReservableMap = new Map();
@@ -282,25 +343,29 @@ describe("isRangeReservable", () => {
   }
 
   test("YES for the base case", () => {
+    const start = addHours(startOfDay(addDays(new Date(), 1)), 10);
     const input = createInput({
-      start: addHours(new Date(), 1),
-      end: addHours(new Date(), 2),
+      start,
+      end: addHours(start, 2),
     });
     expect(isRangeReservable(input)).toBe(true);
   });
 
   test("NO for starting in the past", () => {
+    const now = new Date();
+    const start = addHours(startOfDay(now), now.getHours() - 1);
     const input = createInput({
-      start: addHours(new Date(), -1),
-      end: addHours(new Date(), 2),
+      start,
+      end: addHours(start, 2),
     });
     expect(isRangeReservable(input)).toBe(false);
   });
 
   test("NO if end < start", () => {
+    const start = addHours(startOfDay(Date.now()), 10);
     const input = createInput({
-      start: addHours(new Date(), 2),
-      end: addHours(new Date(), 1),
+      start,
+      end: addHours(start, -1),
     });
     expect(isRangeReservable(input)).toBe(false);
   });
@@ -327,18 +392,28 @@ describe("isRangeReservable", () => {
   test("YES if the range is exactly an interval", () => {
     const date = startOfDay(addDays(new Date(), 1));
     const input = createInput({
-      start: addHours(date, 9),
-      end: addHours(date, 11),
+      start: addHours(date, 10),
+      end: addHours(date, 12),
       interval: ReservationStartInterval.Interval_120Mins,
     });
     expect(isRangeReservable(input)).toBe(true);
   });
 
+  test("NO if the range start time doesn't match interval", () => {
+    const date = startOfDay(addDays(new Date(), 1));
+    const input = createInput({
+      start: addHours(date, 11),
+      end: addHours(date, 13),
+      interval: ReservationStartInterval.Interval_120Mins,
+    });
+    expect(isRangeReservable(input)).toBe(false);
+  });
+
   test("NO if the range is not divisible with interval", () => {
     const date = startOfDay(addDays(new Date(), 1));
     const input = createInput({
-      start: addHours(date, 9),
-      end: addHours(date, 12),
+      start: addHours(date, 10),
+      end: addHours(date, 13),
       interval: ReservationStartInterval.Interval_120Mins,
     });
     expect(isRangeReservable(input)).toBe(false);

apps/ui/modules/__tests__/reservationUnit.test.ts

@@ -56,6 +56,7 @@ jest.mock("next-i18next", () => ({
 describe("getPossibleTimesForDay", () => {
   beforeAll(() => {
     jest.useFakeTimers({
+      doNotFake: ["performance"],
       // use two numbers for hour so we don't need to pad with 0
       now: new Date(2024, 0, 1, 10, 0, 0),
     });
@@ -183,6 +184,24 @@ describe("getPossibleTimesForDay", () => {
     const input = createInput({ date, duration: 150, reservableTimes });
     expect(getPossibleTimesForDay(input)).toStrictEqual([]);
   });
+
+  // getPossibleTimesForDay does multiple calls to isRangeReservable which is heavy
+  // a lot of array copying / generation
+  test("performance", () => {
+    const date = startOfToday();
+    const reservableTimes = mockReservableTimes();
+    reservableTimes.set(dateToKey(date), [
+      { start: addHours(date, 10), end: addHours(date, 11) },
+      { start: addHours(date, 12), end: addHours(date, 14) },
+      { start: addHours(date, 16), end: addHours(date, 18) },
+      { start: addHours(date, 19), end: addHours(date, 20) },
+    ]);
+    const input = createInput({ date, reservableTimes });
+    const start = performance.now();
+    getPossibleTimesForDay(input);
+    const end = performance.now();
+    expect(end - start).toBeLessThan(20);
+  });
 });
 
 describe("getPrice", () => {