@happychef/algorithm 1.2.9 → 1.2.11

package/__tests__/filters.test.js

@@ -0,0 +1,276 @@
+const { filterTimeblocksByMaxArrivals } = require('../filters/maxArrivalsFilter');
+const { filterTimeblocksByMaxGroups } = require('../filters/maxGroupsFilter');
+
+describe('maxArrivalsFilter', () => {
+  test('should keep timeblocks when no max arrivals config exists', () => {
+    const restaurantData = {};
+    const timeblocks = {
+      '12:00': { name: '12:00' },
+      '12:30': { name: '12:30' }
+    };
+    const result = filterTimeblocksByMaxArrivals(restaurantData, '2025-06-15', timeblocks, [], 4);
+    expect(result).toEqual(timeblocks);
+  });
+
+  test('should filter out timeblocks that exceed max arrivals', () => {
+    const restaurantData = {
+      'max-arrivals-lunch': {
+        '12:00': 10,
+        '12:30': 8
+      }
+    };
+    const timeblocks = {
+      '12:00': { name: '12:00' },
+      '12:30': { name: '12:30' }
+    };
+    const reservations = [
+      { date: '2025-06-15', time: '12:00', guests: 8 }
+    ];
+
+    // Adding 4 guests to 12:00 (8 + 4 = 12 > 10) should filter it out
+    const result = filterTimeblocksByMaxArrivals(restaurantData, '2025-06-15', timeblocks, reservations, 4);
+    expect(result['12:00']).toBeUndefined();
+    expect(result['12:30']).toBeDefined();
+  });
+
+  test('should keep timeblocks when within max arrivals limit', () => {
+    const restaurantData = {
+      'max-arrivals-lunch': {
+        '12:00': 20
+      }
+    };
+    const timeblocks = {
+      '12:00': { name: '12:00' }
+    };
+    const reservations = [
+      { date: '2025-06-15', time: '12:00', guests: 10 }
+    ];
+
+    const result = filterTimeblocksByMaxArrivals(restaurantData, '2025-06-15', timeblocks, reservations, 5);
+    expect(result['12:00']).toBeDefined();
+  });
+
+  test('should handle MongoDB NumberInt format', () => {
+    const restaurantData = {
+      'max-arrivals-lunch': {
+        '12:00': { $numberInt: '20' }
+      }
+    };
+    const timeblocks = {
+      '12:00': { name: '12:00' }
+    };
+    const reservations = [
+      { date: '2025-06-15', time: '12:00', guests: 15 }
+    ];
+
+    const result = filterTimeblocksByMaxArrivals(restaurantData, '2025-06-15', timeblocks, reservations, 5);
+    expect(result['12:00']).toBeDefined();
+  });
+
+  test('should handle breakfast times correctly', () => {
+    const restaurantData = {
+      'max-arrivals-breakfast': {
+        '09:00': 15
+      }
+    };
+    const timeblocks = {
+      '09:00': { name: '09:00' }
+    };
+    const reservations = [
+      { date: '2025-06-15', time: '09:00', guests: 12 }
+    ];
+
+    const result = filterTimeblocksByMaxArrivals(restaurantData, '2025-06-15', timeblocks, reservations, 2);
+    expect(result['09:00']).toBeDefined();
+  });
+
+  test('should handle dinner times correctly', () => {
+    const restaurantData = {
+      'max-arrivals-dinner': {
+        '18:00': 30
+      }
+    };
+    const timeblocks = {
+      '18:00': { name: '18:00' }
+    };
+    const reservations = [
+      { date: '2025-06-15', time: '18:00', guests: 20 }
+    ];
+
+    const result = filterTimeblocksByMaxArrivals(restaurantData, '2025-06-15', timeblocks, reservations, 5);
+    expect(result['18:00']).toBeDefined();
+  });
+
+  test('should only count arrivals on the specific date', () => {
+    const restaurantData = {
+      'max-arrivals-lunch': {
+        '12:00': 10
+      }
+    };
+    const timeblocks = {
+      '12:00': { name: '12:00' }
+    };
+    const reservations = [
+      { date: '2025-06-14', time: '12:00', guests: 8 }, // Different date
+      { date: '2025-06-15', time: '12:00', guests: 2 }
+    ];
+
+    const result = filterTimeblocksByMaxArrivals(restaurantData, '2025-06-15', timeblocks, reservations, 5);
+    expect(result['12:00']).toBeDefined(); // 2 + 5 = 7 <= 10
+  });
+});
+
+describe('maxGroupsFilter', () => {
+  test('should keep timeblocks when no max groups config exists', () => {
+    const restaurantData = {};
+    const timeblocks = {
+      '12:00': { name: '12:00' },
+      '12:30': { name: '12:30' }
+    };
+    const result = filterTimeblocksByMaxGroups(restaurantData, '2025-06-15', timeblocks, [], 4);
+    expect(result).toEqual(timeblocks);
+  });
+
+  test('should filter out timeblocks that exceed max groups for a size threshold', () => {
+    const restaurantData = {
+      'max-groups-lunch': {
+        '6': 2 // Max 2 groups of 6+ people
+      }
+    };
+    const timeblocks = {
+      '12:00': { name: '12:00' },
+      '13:00': { name: '13:00' }
+    };
+    const reservations = [
+      { date: '2025-06-15', time: '12:00', guests: 7 },
+      { date: '2025-06-15', time: '12:30', guests: 8 }
+    ];
+
+    // Already have 2 groups of 6+, so adding another should be blocked
+    const result = filterTimeblocksByMaxGroups(restaurantData, '2025-06-15', timeblocks, reservations, 6);
+    expect(Object.keys(result)).toHaveLength(0);
+  });
+
+  test('should keep timeblocks when within max groups limit', () => {
+    const restaurantData = {
+      'max-groups-lunch': {
+        '6': 3 // Max 3 groups of 6+ people
+      }
+    };
+    const timeblocks = {
+      '12:00': { name: '12:00' }
+    };
+    const reservations = [
+      { date: '2025-06-15', time: '12:00', guests: 7 }
+    ];
+
+    const result = filterTimeblocksByMaxGroups(restaurantData, '2025-06-15', timeblocks, reservations, 6);
+    expect(result['12:00']).toBeDefined(); // 1 + 1 = 2 <= 3
+  });
+
+  test('should not apply filter if new booking is smaller than threshold', () => {
+    const restaurantData = {
+      'max-groups-lunch': {
+        '6': 1 // Max 1 group of 6+ people
+      }
+    };
+    const timeblocks = {
+      '12:00': { name: '12:00' }
+    };
+    const reservations = [
+      { date: '2025-06-15', time: '12:00', guests: 8 }
+    ];
+
+    // Booking for 4 people - doesn't meet the 6+ threshold
+    const result = filterTimeblocksByMaxGroups(restaurantData, '2025-06-15', timeblocks, reservations, 4);
+    expect(result['12:00']).toBeDefined();
+  });
+
+  test('should handle MongoDB NumberInt format', () => {
+    const restaurantData = {
+      'max-groups-lunch': {
+        '6': { $numberInt: '2' }
+      }
+    };
+    const timeblocks = {
+      '12:00': { name: '12:00' }
+    };
+    const reservations = [
+      { date: '2025-06-15', time: '12:00', guests: 7 }
+    ];
+
+    const result = filterTimeblocksByMaxGroups(restaurantData, '2025-06-15', timeblocks, reservations, 6);
+    expect(result['12:00']).toBeDefined();
+  });
+
+  test('should handle multiple thresholds correctly', () => {
+    const restaurantData = {
+      'max-groups-lunch': {
+        '6': 2,
+        '10': 1
+      }
+    };
+    const timeblocks = {
+      '12:00': { name: '12:00' }
+    };
+    const reservations = [
+      { date: '2025-06-15', time: '12:00', guests: 12 } // Already have 1 group of 10+
+    ];
+
+    // Trying to add another 10+ group should be blocked
+    const result = filterTimeblocksByMaxGroups(restaurantData, '2025-06-15', timeblocks, reservations, 10);
+    expect(Object.keys(result)).toHaveLength(0);
+  });
+
+  test('should only count reservations for the same meal type', () => {
+    const restaurantData = {
+      'max-groups-lunch': {
+        '6': 1
+      },
+      'max-groups-dinner': {
+        '6': 1
+      }
+    };
+    const timeblocks = {
+      '12:00': { name: '12:00' } // lunch
+    };
+    const reservations = [
+      { date: '2025-06-15', time: '18:00', guests: 8 } // dinner - different meal type
+    ];
+
+    const result = filterTimeblocksByMaxGroups(restaurantData, '2025-06-15', timeblocks, reservations, 7);
+    expect(result['12:00']).toBeDefined(); // Dinner reservation doesn't count for lunch
+  });
+
+  test('should handle breakfast times correctly', () => {
+    const restaurantData = {
+      'max-groups-breakfast': {
+        '4': 3
+      }
+    };
+    const timeblocks = {
+      '09:00': { name: '09:00' }
+    };
+    const reservations = [
+      { date: '2025-06-15', time: '08:00', guests: 5 },
+      { date: '2025-06-15', time: '09:30', guests: 4 }
+    ];
+
+    const result = filterTimeblocksByMaxGroups(restaurantData, '2025-06-15', timeblocks, reservations, 6);
+    expect(result['09:00']).toBeDefined();
+  });
+
+  test('should handle invalid guest counts gracefully', () => {
+    const restaurantData = {
+      'max-groups-lunch': {
+        '6': 2
+      }
+    };
+    const timeblocks = {
+      '12:00': { name: '12:00' }
+    };
+
+    const result = filterTimeblocksByMaxGroups(restaurantData, '2025-06-15', timeblocks, [], 'invalid');
+    expect(result).toEqual(timeblocks); // Should return unfiltered
+  });
+});

package/__tests__/isDateAvailable.test.js

@@ -0,0 +1,175 @@
+const { isDateAvailable } = require('../isDateAvailable');
+
+// Mock the getAvailableTimeblocks function
+jest.mock('../getAvailableTimeblocks', () => ({
+  getAvailableTimeblocks: jest.fn()
+}));
+
+const { getAvailableTimeblocks } = require('../getAvailableTimeblocks');
+
+describe('isDateAvailable', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('should return true when timeblocks are available', () => {
+    getAvailableTimeblocks.mockReturnValue({
+      '12:00': { name: '12:00' },
+      '12:30': { name: '12:30' }
+    });
+
+    const data = {
+      'general-settings': {
+        dagenInToekomst: 90
+      }
+    };
+
+    const result = isDateAvailable(data, '2025-06-15', [], 4, [], null, false);
+    expect(result).toBe(true);
+    expect(getAvailableTimeblocks).toHaveBeenCalledWith(
+      data,
+      '2025-06-15',
+      [],
+      4,
+      [],
+      null,
+      false
+    );
+  });
+
+  test('should return false when no timeblocks are available', () => {
+    getAvailableTimeblocks.mockReturnValue({});
+
+    const data = {
+      'general-settings': {
+        dagenInToekomst: 90
+      }
+    };
+
+    const result = isDateAvailable(data, '2025-06-15', [], 4);
+    expect(result).toBe(false);
+  });
+
+  test('should return false when date is outside allowed range (non-admin)', () => {
+    getAvailableTimeblocks.mockReturnValue({});
+
+    const data = {
+      'general-settings': {
+        dagenInToekomst: 1 // Only 1 day in future
+      }
+    };
+
+    // Use a date far in the future - the function will calculate if it's out of range
+    const result = isDateAvailable(data, '2099-12-31', [], 4, [], null, false);
+    expect(result).toBe(false);
+  });
+
+  test('should allow dates outside range when isAdmin is true', () => {
+    getAvailableTimeblocks.mockReturnValue({
+      '12:00': { name: '12:00' }
+    });
+
+    const data = {
+      'general-settings': {
+        dagenInToekomst: 1
+      }
+    };
+
+    const result = isDateAvailable(data, '2099-12-31', [], 4, [], null, true);
+    expect(result).toBe(true);
+  });
+
+  test('should use default dagenInToekomst of 90 when not specified', () => {
+    getAvailableTimeblocks.mockReturnValue({
+      '12:00': { name: '12:00' }
+    });
+
+    const data = {
+      'general-settings': {}
+    };
+
+    // Use a reasonable date within 90 days
+    const result = isDateAvailable(data, '2025-02-01', [], 4);
+    expect(result).toBe(true);
+  });
+
+  test('should handle giftcard parameter', () => {
+    getAvailableTimeblocks.mockReturnValue({
+      '12:00': { name: '12:00' }
+    });
+
+    const data = {
+      'general-settings': {
+        dagenInToekomst: 90
+      }
+    };
+
+    const result = isDateAvailable(data, '2025-02-01', [], 4, [], 'LUNCH50');
+    expect(result).toBe(true);
+    expect(getAvailableTimeblocks).toHaveBeenCalledWith(
+      data,
+      '2025-02-01',
+      [],
+      4,
+      [],
+      'LUNCH50',
+      false
+    );
+  });
+
+  test('should handle blockedSlots parameter', () => {
+    getAvailableTimeblocks.mockReturnValue({
+      '12:00': { name: '12:00' }
+    });
+
+    const data = {
+      'general-settings': {
+        dagenInToekomst: 90
+      }
+    };
+
+    const blockedSlots = [
+      { date: '2025-02-01', time: '13:00' }
+    ];
+
+    const result = isDateAvailable(data, '2025-02-01', [], 4, blockedSlots);
+    expect(result).toBe(true);
+    expect(getAvailableTimeblocks).toHaveBeenCalledWith(
+      data,
+      '2025-02-01',
+      [],
+      4,
+      blockedSlots,
+      null,
+      false
+    );
+  });
+
+  test('should handle reservations array', () => {
+    getAvailableTimeblocks.mockReturnValue({
+      '12:00': { name: '12:00' }
+    });
+
+    const data = {
+      'general-settings': {
+        dagenInToekomst: 90
+      }
+    };
+
+    const reservations = [
+      { date: '2025-02-01', time: '12:00', guests: 2 }
+    ];
+
+    const result = isDateAvailable(data, '2025-02-01', reservations, 4);
+    expect(result).toBe(true);
+    expect(getAvailableTimeblocks).toHaveBeenCalledWith(
+      data,
+      '2025-02-01',
+      reservations,
+      4,
+      [],
+      null,
+      false
+    );
+  });
+});

package/__tests__/isTimeAvailable.test.js

@@ -0,0 +1,168 @@
+const { isTimeAvailable } = require('../isTimeAvailable');
+
+// Mock the timeblocksAvailable function
+jest.mock('../processing/timeblocksAvailable', () => ({
+  timeblocksAvailable: jest.fn()
+}));
+
+const { timeblocksAvailable } = require('../processing/timeblocksAvailable');
+
+describe('isTimeAvailable', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('should return true when the specific time is available', () => {
+    timeblocksAvailable.mockReturnValue({
+      '12:00': { name: '12:00' },
+      '12:30': { name: '12:30' },
+      '13:00': { name: '13:00' }
+    });
+
+    const data = { 'general-settings': {} };
+    const result = isTimeAvailable(data, '2025-06-15', '12:30', [], 4);
+
+    expect(result).toBe(true);
+    expect(timeblocksAvailable).toHaveBeenCalledWith(
+      data,
+      '2025-06-15',
+      [],
+      4,
+      [],
+      null,
+      false
+    );
+  });
+
+  test('should return false when the specific time is not available', () => {
+    timeblocksAvailable.mockReturnValue({
+      '12:00': { name: '12:00' },
+      '13:00': { name: '13:00' }
+    });
+
+    const data = { 'general-settings': {} };
+    const result = isTimeAvailable(data, '2025-06-15', '12:30', [], 4);
+
+    expect(result).toBe(false);
+  });
+
+  test('should return false when no timeblocks are available', () => {
+    timeblocksAvailable.mockReturnValue({});
+
+    const data = { 'general-settings': {} };
+    const result = isTimeAvailable(data, '2025-06-15', '12:00', [], 4);
+
+    expect(result).toBe(false);
+  });
+
+  test('should handle reservations parameter', () => {
+    timeblocksAvailable.mockReturnValue({
+      '12:00': { name: '12:00' }
+    });
+
+    const data = { 'general-settings': {} };
+    const reservations = [
+      { date: '2025-06-15', time: '11:00', guests: 2 }
+    ];
+
+    const result = isTimeAvailable(data, '2025-06-15', '12:00', reservations, 4);
+
+    expect(result).toBe(true);
+    expect(timeblocksAvailable).toHaveBeenCalledWith(
+      data,
+      '2025-06-15',
+      reservations,
+      4,
+      [],
+      null,
+      false
+    );
+  });
+
+  test('should handle blockedSlots parameter', () => {
+    timeblocksAvailable.mockReturnValue({
+      '12:00': { name: '12:00' }
+    });
+
+    const data = { 'general-settings': {} };
+    const blockedSlots = [
+      { date: '2025-06-15', time: '13:00' }
+    ];
+
+    const result = isTimeAvailable(data, '2025-06-15', '12:00', [], 4, blockedSlots);
+
+    expect(result).toBe(true);
+    expect(timeblocksAvailable).toHaveBeenCalledWith(
+      data,
+      '2025-06-15',
+      [],
+      4,
+      blockedSlots,
+      null,
+      false
+    );
+  });
+
+  test('should handle giftcard parameter', () => {
+    timeblocksAvailable.mockReturnValue({
+      '12:00': { name: '12:00' }
+    });
+
+    const data = { 'general-settings': {} };
+
+    const result = isTimeAvailable(data, '2025-06-15', '12:00', [], 4, [], 'LUNCH50');
+
+    expect(result).toBe(true);
+    expect(timeblocksAvailable).toHaveBeenCalledWith(
+      data,
+      '2025-06-15',
+      [],
+      4,
+      [],
+      'LUNCH50',
+      false
+    );
+  });
+
+  test('should handle isAdmin parameter', () => {
+    timeblocksAvailable.mockReturnValue({
+      '12:00': { name: '12:00' }
+    });
+
+    const data = { 'general-settings': {} };
+
+    const result = isTimeAvailable(data, '2025-06-15', '12:00', [], 4, [], null, true);
+
+    expect(result).toBe(true);
+    expect(timeblocksAvailable).toHaveBeenCalledWith(
+      data,
+      '2025-06-15',
+      [],
+      4,
+      [],
+      null,
+      true
+    );
+  });
+
+  test('should handle different guest counts', () => {
+    timeblocksAvailable.mockReturnValue({
+      '12:00': { name: '12:00' }
+    });
+
+    const data = { 'general-settings': {} };
+
+    const result = isTimeAvailable(data, '2025-06-15', '12:00', [], 10);
+
+    expect(result).toBe(true);
+    expect(timeblocksAvailable).toHaveBeenCalledWith(
+      data,
+      '2025-06-15',
+      [],
+      10,
+      [],
+      null,
+      false
+    );
+  });
+});