[scheduler] Add tests for eventCalendarEventSelectors

packages/x-scheduler-headless/src/event-calendar-selectors/eventCalendarEventSelectors.test.ts

@@ -0,0 +1,180 @@
+import { EventBuilder, getEventCalendarStateFromParameters } from 'test/utils/scheduler';
+import { eventCalendarEventSelectors } from './eventCalendarEventSelectors';
+
+const defaultEvent = EventBuilder.new().id('event-1').build();
+const readOnlyEvent = EventBuilder.new().id('event-1').readOnly(true).build();
+
+describe('eventCalendarEventSelectors', () => {
+  describe('isDraggable', () => {
+    it('should return false when areEventsDraggable is not defined', () => {
+      const state = getEventCalendarStateFromParameters({
+        events: [defaultEvent],
+        areEventsDraggable: undefined,
+      });
+      expect(eventCalendarEventSelectors.isDraggable(state, 'event-1')).to.equal(false);
+    });
+
+    it('should return false when areEventsDraggable is false', () => {
+      const state = getEventCalendarStateFromParameters({
+        events: [defaultEvent],
+        areEventsDraggable: false,
+      });
+      expect(eventCalendarEventSelectors.isDraggable(state, 'event-1')).to.equal(false);
+    });
+
+    it('should return false when the event is read-only', () => {
+      const state = getEventCalendarStateFromParameters({
+        events: [readOnlyEvent],
+        areEventsDraggable: true,
+      });
+      expect(eventCalendarEventSelectors.isDraggable(state, 'event-1')).to.equal(false);
+    });
+
+    it('should return false when the calendar is read-only', () => {
+      const state = getEventCalendarStateFromParameters({
+        events: [defaultEvent],
+        areEventsDraggable: true,
+        readOnly: true,
+      });
+      expect(eventCalendarEventSelectors.isDraggable(state, 'event-1')).to.equal(false);
+    });
+
+    it('should return false when the event start property is read-only', () => {
+      const state = getEventCalendarStateFromParameters({
+        events: [defaultEvent],
+        areEventsDraggable: true,
+        eventModelStructure: {
+          start: { getter: (event) => event.start },
+        },
+      });
+      expect(eventCalendarEventSelectors.isDraggable(state, 'event-1')).to.equal(false);
+    });
+
+    it('should return false when the event end property is read-only', () => {
+      const state = getEventCalendarStateFromParameters({
+        events: [defaultEvent],
+        areEventsDraggable: true,
+        eventModelStructure: {
+          end: { getter: (event) => event.end },
+        },
+      });
+      expect(eventCalendarEventSelectors.isDraggable(state, 'event-1')).to.equal(false);
+    });
+
+    it('should return true when areEventsDraggable is true and the event is not read-only', () => {
+      const state = getEventCalendarStateFromParameters({
+        events: [defaultEvent],
+        areEventsDraggable: true,
+      });
+      expect(eventCalendarEventSelectors.isDraggable(state, 'event-1')).to.equal(true);
+    });
+  });
+
+  describe('isResizable', () => {
+    it('should return false when areEventsResizable is not defined', () => {
+      const state = getEventCalendarStateFromParameters({
+        events: [defaultEvent],
+        view: 'week',
+        areEventsResizable: undefined,
+      });
+      expect(eventCalendarEventSelectors.isResizable(state, 'event-1', 'day-grid')).to.equal(false);
+    });
+
+    it('should return false when areEventsResizable is false', () => {
+      const state = getEventCalendarStateFromParameters({
+        events: [defaultEvent],
+        view: 'week',
+        areEventsResizable: false,
+      });
+      expect(eventCalendarEventSelectors.isResizable(state, 'event-1', 'day-grid')).to.equal(false);
+    });
+
+    it('should return false when the event is read-only', () => {
+      const state = getEventCalendarStateFromParameters({
+        events: [readOnlyEvent],
+        view: 'week',
+        areEventsResizable: true,
+      });
+      expect(eventCalendarEventSelectors.isResizable(state, 'event-1', 'day-grid')).to.equal(false);
+    });
+
+    it('should return false when the calendar is read-only', () => {
+      const state = getEventCalendarStateFromParameters({
+        events: [defaultEvent],
+        view: 'week',
+        areEventsResizable: true,
+        readOnly: true,
+      });
+      expect(eventCalendarEventSelectors.isResizable(state, 'event-1', 'day-grid')).to.equal(false);
+    });
+
+    it('should return false when the event start property is read-only', () => {
+      const state = getEventCalendarStateFromParameters({
+        events: [defaultEvent],
+        view: 'week',
+        areEventsResizable: true,
+        eventModelStructure: {
+          start: { getter: (event) => event.start },
+        },
+      });
+      expect(eventCalendarEventSelectors.isResizable(state, 'event-1', 'day-grid')).to.equal(false);
+    });
+
+    it('should return false when the event end property is read-only', () => {
+      const state = getEventCalendarStateFromParameters({
+        events: [defaultEvent],
+        view: 'week',
+        areEventsResizable: true,
+        eventModelStructure: {
+          end: { getter: (event) => event.end },
+        },
+      });
+      expect(eventCalendarEventSelectors.isResizable(state, 'event-1', 'day-grid')).to.equal(false);
+    });
+
+    it('should return true when areEventsResizable is true and the event is not read-only', () => {
+      const state = getEventCalendarStateFromParameters({
+        events: [defaultEvent],
+        view: 'week',
+        areEventsResizable: true,
+      });
+      expect(eventCalendarEventSelectors.isResizable(state, 'event-1', 'day-grid')).to.equal(true);
+    });
+
+    it('should return false in day view on day-grid surface', () => {
+      const state = getEventCalendarStateFromParameters({
+        events: [defaultEvent],
+        view: 'day',
+        areEventsResizable: true,
+      });
+      expect(eventCalendarEventSelectors.isResizable(state, 'event-1', 'day-grid')).to.equal(false);
+    });
+
+    it('should return true in day view on time-grid surface', () => {
+      const state = getEventCalendarStateFromParameters({
+        events: [defaultEvent],
+        view: 'day',
+        areEventsResizable: true,
+      });
+      expect(eventCalendarEventSelectors.isResizable(state, 'event-1', 'time-grid')).to.equal(true);
+    });
+
+    it('should return false in month view on day-grid surface for single-day events', () => {
+      const state = getEventCalendarStateFromParameters({
+        events: [defaultEvent],
+        view: 'month',
+        areEventsResizable: true,
+      });
+      expect(eventCalendarEventSelectors.isResizable(state, 'event-1', 'day-grid')).to.equal(false);
+    });
+
+    it('should return true in month view on day-grid surface for multi-day events', () => {
+      const state = getEventCalendarStateFromParameters({
+        events: [{ ...defaultEvent, allDay: true }],
+        view: 'month',
+        areEventsResizable: true,
+      });
+      expect(eventCalendarEventSelectors.isResizable(state, 'event-1', 'day-grid')).to.equal(true);
+    });
+  });
+});

packages/x-scheduler-headless/src/event-calendar-selectors/eventCalendarEventSelectors.ts

@@ -26,7 +26,7 @@ export const eventCalendarEventSelectors = {
   ),
   isResizable: createSelector(
     (state: State, eventId: CalendarEventId, surfaceType: EventSurfaceType) => {
-      if (schedulerEventSelectors.isReadOnly(state, eventId) || !state.areEventsDraggable) {
+      if (schedulerEventSelectors.isReadOnly(state, eventId) || !state.areEventsResizable) {
         return false;
       }