@happychef/algorithm 1.3.0 → 1.4.0

package/__tests__/crossMidnight.test.js

@@ -0,0 +1,63 @@
+// __tests__/crossMidnight.test.js
+// Tests for cross-midnight reservation support (consecutive slots across days)
+
+const { getNextDateStr, getPrevDateStr } = require('../dateHelpers');
+
+// --- dateHelpers tests ---
+describe('dateHelpers', () => {
+  test('getNextDateStr returns next day', () => {
+    expect(getNextDateStr('2025-02-20')).toBe('2025-02-21');
+    expect(getNextDateStr('2025-02-28')).toBe('2025-03-01');
+    expect(getNextDateStr('2025-12-31')).toBe('2026-01-01');
+  });
+
+  test('getPrevDateStr returns previous day', () => {
+    expect(getPrevDateStr('2025-02-21')).toBe('2025-02-20');
+    expect(getPrevDateStr('2025-03-01')).toBe('2025-02-28');
+    expect(getPrevDateStr('2026-01-01')).toBe('2025-12-31');
+  });
+});
+
+// --- counter.js: getGuestCountAtHour with previous-day spillover ---
+const { getGuestCountAtHour } = require('../reservation_data/counter');
+
+describe('getGuestCountAtHour - previous-day spillover', () => {
+  const data = {
+    'general-settings': {
+      duurReservatie: '60',
+      intervalReservatie: '15',
+    },
+  };
+
+  test('counts same-day reservation guests at overlapping hour', () => {
+    const reservations = [
+      { date: '2025-02-20', time: '22:00', guests: 4, duration: 120 },
+    ];
+    const count = getGuestCountAtHour(data, reservations, '22:30', '2025-02-20');
+    expect(count).toBe(4);
+  });
+
+  test('counts previous-day spillover guests after midnight', () => {
+    const reservations = [
+      { date: '2025-02-19', time: '23:00', guests: 6, duration: 180 },
+    ];
+    const count = getGuestCountAtHour(data, reservations, '01:00', '2025-02-20');
+    expect(count).toBe(6);
+  });
+
+  test('does not count previous-day reservation that ended before target time', () => {
+    const reservations = [
+      { date: '2025-02-19', time: '23:00', guests: 6, duration: 120 },
+    ];
+    const count = getGuestCountAtHour(data, reservations, '01:30', '2025-02-20');
+    expect(count).toBe(0);
+  });
+
+  test('does not count previous-day reservation that does not cross midnight', () => {
+    const reservations = [
+      { date: '2025-02-19', time: '20:00', guests: 4, duration: 60 },
+    ];
+    const count = getGuestCountAtHour(data, reservations, '00:30', '2025-02-20');
+    expect(count).toBe(0);
+  });
+});

package/__tests__/crossMidnightTimeblocks.test.js

@@ -0,0 +1,312 @@
+// __tests__/crossMidnightTimeblocks.test.js
+// Tests for timeblocksAvailable cross-midnight slot generation
+
+jest.mock('../restaurant_data/exceptions', () => ({
+  getDataByDateAndMealWithExceptions: jest.fn(),
+  getDataByDateAndTimeWithExceptions: jest.fn(),
+}));
+
+jest.mock('../restaurant_data/openinghours', () => ({
+  getMealTypeByTime: jest.fn(),
+  parseTime: jest.fn((timeStr) => {
+    const [h, m] = timeStr.split(':').map(Number);
+    return h * 60 + m;
+  }),
+  daysOfWeekEnglish: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],
+}));
+
+jest.mock('../processing/dailyGuestCounts', () => ({
+  getDailyGuestCounts: jest.fn(),
+}));
+
+jest.mock('../processing/mealTypeCount', () => ({
+  getMealTypesWithShifts: jest.fn(),
+}));
+
+jest.mock('../reservation_data/counter', () => ({
+  getGuestCountAtHour: jest.fn(),
+}));
+
+const { timeblocksAvailable } = require('../processing/timeblocksAvailable');
+const { getDataByDateAndMealWithExceptions } = require('../restaurant_data/exceptions');
+const { getDailyGuestCounts } = require('../processing/dailyGuestCounts');
+const { getMealTypesWithShifts } = require('../processing/mealTypeCount');
+const { getGuestCountAtHour: mockGetGuestCountAtHour } = require('../reservation_data/counter');
+const { getMealTypeByTime } = require('../restaurant_data/openinghours');
+
+describe('timeblocksAvailable - cross-midnight', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  // Per-day format: hoursOpenedPastMidnight in openinghours-dinner.schemeSettings
+  function setupBowlingData(hoursOpenedPastMidnight = 3) {
+    const days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'];
+    const schemeSettings = {};
+    for (const day of days) {
+      schemeSettings[day] = { hoursOpenedPastMidnight };
+    }
+
+    const data = {
+      'general-settings': {
+        duurReservatie: '60',
+        intervalReservatie: '30',
+      },
+      'openinghours-dinner': {
+        schemeSettings,
+      },
+    };
+
+    // Bowling restaurant: dinner 16:00-24:00
+    getDataByDateAndMealWithExceptions.mockImplementation((_data, dateStr, mealType) => {
+      if (mealType === 'dinner') {
+        return {
+          enabled: true,
+          startTime: '16:00',
+          endTime: '24:00',
+          maxCapacity: 40,
+        };
+      }
+      return null;
+    });
+
+    getMealTypesWithShifts.mockReturnValue([]);
+
+    return data;
+  }
+
+  // Per-day format with different values per day
+  function setupPerDayData(perDayValues) {
+    const schemeSettings = {};
+    for (const [day, val] of Object.entries(perDayValues)) {
+      schemeSettings[day] = { hoursOpenedPastMidnight: val };
+    }
+
+    const data = {
+      'general-settings': {
+        duurReservatie: '60',
+        intervalReservatie: '30',
+      },
+      'openinghours-dinner': {
+        schemeSettings,
+      },
+    };
+
+    getDataByDateAndMealWithExceptions.mockImplementation((_data, dateStr, mealType) => {
+      if (mealType === 'dinner') {
+        return {
+          enabled: true,
+          startTime: '16:00',
+          endTime: '24:00',
+          maxCapacity: 40,
+        };
+      }
+      return null;
+    });
+
+    getMealTypesWithShifts.mockReturnValue([]);
+
+    return data;
+  }
+
+  function makeDinnerGuestCounts() {
+    const guestCounts = {};
+    for (let t = 960; t <= 1410; t += 30) {
+      const h = Math.floor(t / 60);
+      const m = t % 60;
+      const key = `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}`;
+      guestCounts[key] = 38; // 40 - 2 = 38 seats available
+    }
+    return guestCounts;
+  }
+
+  test('generates late-evening slots when hoursOpenedPastMidnight is set', () => {
+    const data = setupBowlingData(3);
+
+    getDailyGuestCounts.mockReturnValue({
+      guestCounts: makeDinnerGuestCounts(),
+      shiftsInfo: [],
+    });
+
+    mockGetGuestCountAtHour.mockReturnValue(0);
+
+    // 2025-02-20 is Thursday
+    const result = timeblocksAvailable(data, '2025-02-20', [], 2, [], null, false, 180);
+
+    // 23:00 + 180min = 02:00, within 3h limit
+    expect(result['23:00']).toBeDefined();
+  });
+
+  test('rejects late slot when next-day spillover guests exceed capacity', () => {
+    const data = setupBowlingData(3);
+
+    getDailyGuestCounts.mockReturnValue({
+      guestCounts: makeDinnerGuestCounts(),
+      shiftsInfo: [],
+    });
+
+    // Next day has 40 guests already (full capacity)
+    mockGetGuestCountAtHour.mockImplementation((_data, _res, timeStr, dateStr) => {
+      if (dateStr === '2025-02-21') return 40;
+      return 0;
+    });
+
+    const result = timeblocksAvailable(data, '2025-02-20', [], 2, [], null, false, 180);
+
+    expect(result['23:00']).toBeUndefined();
+  });
+
+  test('rejects cross-midnight when hoursOpenedPastMidnight is 0', () => {
+    const data = setupBowlingData(0);
+
+    getDailyGuestCounts.mockReturnValue({
+      guestCounts: makeDinnerGuestCounts(),
+      shiftsInfo: [],
+    });
+
+    mockGetGuestCountAtHour.mockReturnValue(0);
+
+    const result = timeblocksAvailable(data, '2025-02-20', [], 2, [], null, false, 180);
+
+    // 23:00 + 180min crosses midnight, but hoursOpenedPastMidnight=0 disallows it
+    expect(result['23:00']).toBeUndefined();
+  });
+
+  test('rejects slot when spillover exceeds hoursOpenedPastMidnight limit', () => {
+    const data = setupBowlingData(1); // Only 1 hour past midnight
+
+    getDailyGuestCounts.mockReturnValue({
+      guestCounts: makeDinnerGuestCounts(),
+      shiftsInfo: [],
+    });
+
+    mockGetGuestCountAtHour.mockReturnValue(0);
+
+    const result = timeblocksAvailable(data, '2025-02-20', [], 2, [], null, false, 180);
+
+    // 23:00 + 180min = 02:00, which is 2h past midnight > 1h limit
+    expect(result['23:00']).toBeUndefined();
+  });
+
+  test('per-day: Friday allows cross-midnight, Monday does not', () => {
+    // Mon-Thu: 0, Fri-Sun: 2
+    const data = setupPerDayData({
+      Monday: 0, Tuesday: 0, Wednesday: 0, Thursday: 0,
+      Friday: 2, Saturday: 2, Sunday: 2,
+    });
+
+    getDailyGuestCounts.mockReturnValue({
+      guestCounts: makeDinnerGuestCounts(),
+      shiftsInfo: [],
+    });
+
+    mockGetGuestCountAtHour.mockReturnValue(0);
+
+    // 2025-02-21 is Friday
+    const fridayResult = timeblocksAvailable(data, '2025-02-21', [], 2, [], null, false, 180);
+    // 23:00 + 180min = 02:00, within 2h limit on Friday
+    expect(fridayResult['23:00']).toBeDefined();
+
+    // 2025-02-17 is Monday
+    const mondayResult = timeblocksAvailable(data, '2025-02-17', [], 2, [], null, false, 180);
+    // 23:00 + 180min = 02:00, but hoursOpenedPastMidnight=0 on Monday
+    expect(mondayResult['23:00']).toBeUndefined();
+  });
+
+  test('backward compat: reads from general-settings when dinner schemeSettings missing', () => {
+    // Old format: hoursOpenedPastMidnight in general-settings only
+    const data = {
+      'general-settings': {
+        duurReservatie: '60',
+        intervalReservatie: '30',
+        hoursOpenedPastMidnight: '3',
+      },
+    };
+
+    getDataByDateAndMealWithExceptions.mockImplementation((_data, dateStr, mealType) => {
+      if (mealType === 'dinner') {
+        return {
+          enabled: true,
+          startTime: '16:00',
+          endTime: '24:00',
+          maxCapacity: 40,
+        };
+      }
+      return null;
+    });
+
+    getMealTypesWithShifts.mockReturnValue([]);
+
+    getDailyGuestCounts.mockReturnValue({
+      guestCounts: makeDinnerGuestCounts(),
+      shiftsInfo: [],
+    });
+
+    mockGetGuestCountAtHour.mockReturnValue(0);
+
+    const result = timeblocksAvailable(data, '2025-02-20', [], 2, [], null, false, 180);
+
+    // Should still work via general-settings fallback
+    expect(result['23:00']).toBeDefined();
+  });
+
+  test('non-bowling: 22:30 is last slot, 23:00 not bookable', () => {
+    const data = {
+      'general-settings': {
+        duurReservatie: '120',
+        intervalReservatie: '30',
+      },
+    };
+
+    getDataByDateAndMealWithExceptions.mockImplementation((_data, dateStr, mealType) => {
+      if (mealType === 'dinner') {
+        return {
+          enabled: true,
+          startTime: '16:00',
+          endTime: '25:00', // 23:00 + 120min default (via addDuurReservatieToEndTime)
+          maxCapacity: 40,
+        };
+      }
+      return null;
+    });
+
+    getMealTypesWithShifts.mockReturnValue([]);
+
+    // Mimic original production shift boundaries (strict < for end)
+    getMealTypeByTime.mockImplementation((timeStr) => {
+      const [h, m] = timeStr.split(':').map(Number);
+      const time = h * 60 + m;
+      if (time >= 420 && time < 660) return 'breakfast';
+      if (time >= 660 && time < 960) return 'lunch';
+      if (time >= 960 && time < 1380) return 'dinner';
+      return null;
+    });
+
+    // guestCounts covers the full extended meal period
+    const guestCounts = {};
+    for (let t = 960; t <= 1500; t += 30) {
+      const h = Math.floor(t / 60);
+      const m = t % 60;
+      const key = `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}`;
+      guestCounts[key] = 38;
+    }
+
+    getDailyGuestCounts.mockReturnValue({
+      guestCounts,
+      shiftsInfo: [],
+    });
+
+    mockGetGuestCountAtHour.mockReturnValue(0);
+
+    const result = timeblocksAvailable(data, '2025-02-20', [], 2, [], null, false, null);
+
+    // Standard restaurant: 18:00 should be available
+    expect(result['18:00']).toBeDefined();
+    // 22:30 is last valid slot (getMealTypeByTime returns 'dinner' for < 23:00)
+    expect(result['22:30']).toBeDefined();
+    // 23:00: getMealTypeByTime returns null (strict < 23:00) → not bookable
+    expect(result['23:00']).toBeUndefined();
+    expect(result['23:30']).toBeUndefined();
+    expect(result['24:00']).toBeUndefined();
+  });
+});

package/__tests__/edgeCases.test.js

@@ -0,0 +1,271 @@
+// __tests__/edgeCases.test.js
+// Edge case tests for bowling vs non-bowling and per-day hoursOpenedPastMidnight
+
+jest.mock('../restaurant_data/exceptions', () => ({
+  getDataByDateAndMealWithExceptions: jest.fn(),
+  getDataByDateAndTimeWithExceptions: jest.fn(),
+}));
+
+jest.mock('../restaurant_data/openinghours', () => ({
+  getMealTypeByTime: jest.fn(),
+  parseTime: jest.fn((timeStr) => {
+    const [h, m] = timeStr.split(':').map(Number);
+    return h * 60 + m;
+  }),
+  daysOfWeekEnglish: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],
+}));
+
+jest.mock('../processing/dailyGuestCounts', () => ({
+  getDailyGuestCounts: jest.fn(),
+}));
+
+jest.mock('../processing/mealTypeCount', () => ({
+  getMealTypesWithShifts: jest.fn(),
+}));
+
+jest.mock('../reservation_data/counter', () => ({
+  getGuestCountAtHour: jest.fn(),
+}));
+
+const { timeblocksAvailable } = require('../processing/timeblocksAvailable');
+const { getDataByDateAndMealWithExceptions } = require('../restaurant_data/exceptions');
+const { getDailyGuestCounts } = require('../processing/dailyGuestCounts');
+const { getMealTypesWithShifts } = require('../processing/mealTypeCount');
+const { getGuestCountAtHour: mockGetGuestCountAtHour } = require('../reservation_data/counter');
+const { getMealTypeByTime } = require('../restaurant_data/openinghours');
+
+// Helper: generate guestCounts from startMin to endMin (inclusive) at given interval
+function makeGuestCounts(startMin, endMin, interval, available = 38) {
+  const gc = {};
+  for (let t = startMin; t <= endMin; t += interval) {
+    const h = Math.floor(t / 60);
+    const m = t % 60;
+    gc[`${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}`] = available;
+  }
+  return gc;
+}
+
+describe('Edge cases: non-bowling restaurants', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    getMealTypesWithShifts.mockReturnValue([]);
+    mockGetGuestCountAtHour.mockReturnValue(0);
+    // Mimic original production shift boundaries (strict < for end)
+    getMealTypeByTime.mockImplementation((timeStr) => {
+      const [h, m] = timeStr.split(':').map(Number);
+      const time = h * 60 + m;
+      if (time >= 420 && time < 660) return 'breakfast';
+      if (time >= 660 && time < 960) return 'lunch';
+      if (time >= 960 && time < 1380) return 'dinner';
+      return null;
+    });
+  });
+
+  test('regular restaurant (no midnight setting): 22:45 is last slot, 23:00 not bookable', () => {
+    const data = {
+      'general-settings': {
+        duurReservatie: '120',
+        intervalReservatie: '15',
+      },
+    };
+
+    getDataByDateAndMealWithExceptions.mockImplementation((_data, _date, mealType) => {
+      if (mealType === 'dinner') {
+        return { enabled: true, startTime: '16:00', endTime: '25:00', maxCapacity: 40 };
+      }
+      return null;
+    });
+
+    // guestCounts 16:00 to 25:00 at 15min interval
+    getDailyGuestCounts.mockReturnValue({
+      guestCounts: makeGuestCounts(960, 1500, 15),
+      shiftsInfo: [],
+    });
+
+    const result = timeblocksAvailable(data, '2025-02-20', [], 2, [], null, false, null);
+
+    expect(result['22:00']).toBeDefined();
+    expect(result['22:45']).toBeDefined();   // last valid slot (getMealTypeByTime returns 'dinner' for < 23:00)
+    expect(result['23:00']).toBeUndefined(); // getMealTypeByTime returns null for 23:00 (strict <)
+    expect(result['23:15']).toBeUndefined();
+    expect(result['23:30']).toBeUndefined();
+    expect(result['24:00']).toBeUndefined();
+  });
+
+  test('regular restaurant with 15min interval and 60min duration: 22:45 is last slot', () => {
+    const data = {
+      'general-settings': {
+        duurReservatie: '60',
+        intervalReservatie: '15',
+      },
+    };
+
+    getDataByDateAndMealWithExceptions.mockImplementation((_data, _date, mealType) => {
+      if (mealType === 'dinner') {
+        // 23:00 + 60min extension = 24:00
+        return { enabled: true, startTime: '16:00', endTime: '24:00', maxCapacity: 40 };
+      }
+      return null;
+    });
+
+    getDailyGuestCounts.mockReturnValue({
+      guestCounts: makeGuestCounts(960, 1440, 15),
+      shiftsInfo: [],
+    });
+
+    const result = timeblocksAvailable(data, '2025-02-20', [], 2, [], null, false, null);
+
+    expect(result['22:45']).toBeDefined();   // last valid (getMealTypeByTime returns 'dinner')
+    expect(result['23:00']).toBeUndefined(); // getMealTypeByTime returns null for 23:00
+    expect(result['23:15']).toBeUndefined();
+    expect(result['23:30']).toBeUndefined();
+    expect(result['24:00']).toBeUndefined();
+  });
+
+  test('regular restaurant lunch: no slots after lunch closing time', () => {
+    const data = {
+      'general-settings': {
+        duurReservatie: '120',
+        intervalReservatie: '15',
+      },
+    };
+
+    getDataByDateAndMealWithExceptions.mockImplementation((_data, _date, mealType) => {
+      if (mealType === 'lunch') {
+        // lunch 11:00-14:00, extended by 120min to 16:00
+        return { enabled: true, startTime: '11:00', endTime: '16:00', maxCapacity: 40 };
+      }
+      return null;
+    });
+
+    getDailyGuestCounts.mockReturnValue({
+      guestCounts: makeGuestCounts(660, 960, 15),
+      shiftsInfo: [],
+    });
+
+    const result = timeblocksAvailable(data, '2025-02-20', [], 2, [], null, false, null);
+
+    expect(result['13:45']).toBeDefined();
+    expect(result['14:00']).toBeDefined();   // original closing
+    expect(result['14:15']).toBeUndefined();  // past closing
+    expect(result['15:00']).toBeUndefined();
+  });
+});
+
+describe('Edge cases: bowling per-day', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    getMealTypesWithShifts.mockReturnValue([]);
+    mockGetGuestCountAtHour.mockReturnValue(0);
+  });
+
+  test('Friday=1hr, Saturday=2hr: Saturday allows more spillover than Friday', () => {
+    const data = {
+      'general-settings': { duurReservatie: '60', intervalReservatie: '15' },
+      'openinghours-dinner': {
+        schemeSettings: {
+          Monday: { hoursOpenedPastMidnight: 0 },
+          Tuesday: { hoursOpenedPastMidnight: 0 },
+          Wednesday: { hoursOpenedPastMidnight: 0 },
+          Thursday: { hoursOpenedPastMidnight: 0 },
+          Friday: { hoursOpenedPastMidnight: 1 },
+          Saturday: { hoursOpenedPastMidnight: 2 },
+          Sunday: { hoursOpenedPastMidnight: 1 },
+        },
+      },
+    };
+
+    getDataByDateAndMealWithExceptions.mockImplementation((_data, _date, mealType) => {
+      if (mealType === 'dinner') {
+        return { enabled: true, startTime: '16:00', endTime: '24:00', maxCapacity: 40 };
+      }
+      return null;
+    });
+
+    getDailyGuestCounts.mockReturnValue({
+      guestCounts: makeGuestCounts(960, 1440, 15),
+      shiftsInfo: [],
+    });
+
+    // 2025-02-21 is Friday
+    const fri = timeblocksAvailable(data, '2025-02-21', [], 2, [], null, false, 90);
+    // 23:30 + 90min = 01:00, within 1hr limit on Friday
+    expect(fri['23:30']).toBeDefined();
+    // 23:45 + 90min = 01:15, exceeds 1hr limit on Friday
+    expect(fri['23:45']).toBeUndefined();
+
+    // 2025-02-22 is Saturday
+    const sat = timeblocksAvailable(data, '2025-02-22', [], 2, [], null, false, 90);
+    // 23:45 + 90min = 01:15, within 2hr limit on Saturday
+    expect(sat['23:45']).toBeDefined();
+  });
+
+  test('bowling Monday (hoursOpenedPastMidnight=0): 23:00 with short duration OK, 23:15 not', () => {
+    const data = {
+      'general-settings': { duurReservatie: '60', intervalReservatie: '15' },
+      'openinghours-dinner': {
+        schemeSettings: {
+          Monday: { hoursOpenedPastMidnight: 0 },
+          Friday: { hoursOpenedPastMidnight: 1 },
+        },
+      },
+    };
+
+    getDataByDateAndMealWithExceptions.mockImplementation((_data, _date, mealType) => {
+      if (mealType === 'dinner') {
+        return { enabled: true, startTime: '16:00', endTime: '24:00', maxCapacity: 40 };
+      }
+      return null;
+    });
+
+    getDailyGuestCounts.mockReturnValue({
+      guestCounts: makeGuestCounts(960, 1440, 15),
+      shiftsInfo: [],
+    });
+
+    // 2025-02-17 is Monday, 60min duration
+    const result = timeblocksAvailable(data, '2025-02-17', [], 2, [], null, false, 60);
+
+    // 23:00 + 60min = 24:00 (midnight exactly), hoursOpenedPastMidnight=0 allows up to midnight
+    expect(result['23:00']).toBeDefined();
+    // 23:15 + 60min = 24:15, past midnight, not allowed
+    expect(result['23:15']).toBeUndefined();
+    // 24:00 + 60min = 25:00, past midnight, not allowed
+    expect(result['24:00']).toBeUndefined();
+  });
+
+  test('bowling Friday (hoursOpenedPastMidnight=1): 23:30, 24:00 show', () => {
+    const data = {
+      'general-settings': { duurReservatie: '60', intervalReservatie: '15' },
+      'openinghours-dinner': {
+        schemeSettings: {
+          Monday: { hoursOpenedPastMidnight: 0 },
+          Friday: { hoursOpenedPastMidnight: 1 },
+        },
+      },
+    };
+
+    getDataByDateAndMealWithExceptions.mockImplementation((_data, _date, mealType) => {
+      if (mealType === 'dinner') {
+        return { enabled: true, startTime: '16:00', endTime: '24:00', maxCapacity: 40 };
+      }
+      return null;
+    });
+
+    getDailyGuestCounts.mockReturnValue({
+      guestCounts: makeGuestCounts(960, 1440, 15),
+      shiftsInfo: [],
+    });
+
+    // 2025-02-21 is Friday, 60min duration
+    const result = timeblocksAvailable(data, '2025-02-21', [], 2, [], null, false, 60);
+
+    expect(result['23:00']).toBeDefined();
+    expect(result['23:15']).toBeDefined();
+    expect(result['23:30']).toBeDefined();
+    expect(result['23:45']).toBeDefined();
+    expect(result['24:00']).toBeDefined();  // 24:00 + 60 = 25:00, within 1hr? No...
+
+    // Wait: 24:00 + 60min = 25:00 → endMinutes=1500, limit=1440+60=1500 → 1500>1500 false → OK
+  });
+});