444 use websocket to trigger reloads (#458)

* [#444] added refresh on sync token calendar update

* [#444] added refresh on register and tests

* [#444] extracted logic for useEffects and updates

* [#444] refactored code structure to use absolute paths

__test__/utils/CalendarRangeManager.test.ts

@@ -0,0 +1,73 @@
+import {
+  getDisplayedDate,
+  setDisplayedDateAndRange,
+  calendarRangeManager,
+  getDisplayedCalendarRange,
+} from "../../src/utils/CalendarRangeManager";
+
+describe("CalendarRangeManager", () => {
+  beforeEach(() => {
+    setDisplayedDateAndRange(new Date());
+  });
+
+  it("should return a singleton instance", () => {
+    const instance1 = calendarRangeManager;
+    const instance2 = calendarRangeManager;
+
+    expect(instance1).toStrictEqual(instance2);
+  });
+
+  it("should compute and return calendar range when date is set", () => {
+    const testDate = new Date("2025-06-15T10:00:00Z");
+    setDisplayedDateAndRange(testDate);
+
+    const range = getDisplayedCalendarRange();
+    expect(range.start).toBeInstanceOf(Date);
+    expect(range.end).toBeInstanceOf(Date);
+    expect(range.start.getTime()).toBeLessThanOrEqual(testDate.getTime());
+    expect(range.end.getTime()).toBeGreaterThanOrEqual(testDate.getTime());
+  });
+
+  it("should get the default date", () => {
+    const date = getDisplayedDate();
+    expect(date).toBeInstanceOf(Date);
+  });
+
+  it("should set and get a date", () => {
+    const testDate = new Date("2025-01-15T10:00:00Z");
+    setDisplayedDateAndRange(testDate);
+
+    const retrievedDate = getDisplayedDate();
+    expect(retrievedDate).toStrictEqual(testDate);
+  });
+
+  it("should persist date across multiple calls", () => {
+    const testDate = new Date("2025-06-20T15:30:00Z");
+    setDisplayedDateAndRange(testDate);
+
+    const date1 = getDisplayedDate();
+    const date2 = getDisplayedDate();
+
+    expect(date1).toStrictEqual(date2);
+    expect(date1).toStrictEqual(testDate);
+  });
+
+  it("should update date when set multiple times", () => {
+    const date1 = new Date("2025-01-01T00:00:00Z");
+    const date2 = new Date("2025-12-31T23:59:59Z");
+
+    setDisplayedDateAndRange(date1);
+    expect(getDisplayedDate()).toStrictEqual(date1);
+
+    setDisplayedDateAndRange(date2);
+    expect(getDisplayedDate()).toStrictEqual(date2);
+  });
+
+  it("should maintain shared state (singleton behavior)", () => {
+    const testDate = new Date("2025-03-01");
+    setDisplayedDateAndRange(testDate);
+
+    // Verify CalendarRangeManager reflects the same state
+    expect(calendarRangeManager.getDate()).toStrictEqual(testDate);
+  });
+});

__test__/utils/findCalendarById.test.ts

@@ -0,0 +1,99 @@
+import { findCalendarById } from "../../src/utils/findCalendarById";
+import { Calendar } from "../../src/features/Calendars/CalendarTypes";
+import { RootState } from "../../src/app/store";
+
+describe("findCalendarById", () => {
+  const mockCalendar1: Calendar = {
+    id: "cal1",
+    name: "Personal",
+    color: { light: "#FF0000" },
+  } as unknown as Calendar;
+
+  const mockCalendar2: Calendar = {
+    id: "cal2",
+    name: "Work",
+    color: { light: "#0000FF" },
+  } as unknown as Calendar;
+
+  const mockTempCalendar: Calendar = {
+    id: "temp1",
+    name: "Temporary",
+    color: { light: "#00FF00" },
+  } as unknown as Calendar;
+
+  const mockState = {
+    calendars: {
+      list: {
+        cal1: mockCalendar1,
+        cal2: mockCalendar2,
+      },
+      templist: {
+        temp1: mockTempCalendar,
+      },
+    },
+  } as unknown as Partial<RootState>;
+
+  it("should find calendar in main list", () => {
+    const result = findCalendarById(mockState, "cal1");
+
+    expect(result?.calendar).toEqual(mockCalendar1);
+    expect(result?.type).toBeUndefined();
+  });
+
+  it("should find calendar in temp list", () => {
+    const result = findCalendarById(mockState, "temp1");
+
+    expect(result?.calendar).toEqual(mockTempCalendar);
+    expect(result?.type).toBe("temp");
+  });
+
+  it("should not return calendar for non-existent id", () => {
+    const result = findCalendarById(mockState, "nonexistent");
+
+    expect(result).toBeUndefined();
+  });
+
+  it("should not return calendar for empty string", () => {
+    const result = findCalendarById(mockState, "");
+
+    expect(result).toBeUndefined();
+  });
+
+  it("should prioritize main list over temp list", () => {
+    const stateWithDuplicate = {
+      calendars: {
+        list: {
+          dup1: mockCalendar1,
+        },
+        templist: {
+          dup1: mockTempCalendar,
+        },
+      },
+    } as unknown as Partial<RootState>;
+
+    const result = findCalendarById(stateWithDuplicate, "dup1");
+
+    expect(result?.calendar).toEqual(mockCalendar1);
+    expect(result?.type).toBeUndefined();
+  });
+
+  it("should handle undefined list or templist", () => {
+    const stateWithPartialCalendars = {
+      calendars: {
+        list: undefined,
+        templist: { temp1: mockTempCalendar },
+      },
+    } as unknown as Partial<RootState>;
+
+    const result = findCalendarById(stateWithPartialCalendars, "temp1");
+    expect(result?.calendar).toEqual(mockTempCalendar);
+  });
+
+  it("should handle missing calendars state", () => {
+    const emptyState = {};
+
+    const result = findCalendarById(emptyState, "cal1");
+
+    expect(result).toBeUndefined();
+  });
+});