Camille Moussu
860 lines
25 KiB
TypeScript
860 lines
25 KiB
TypeScript
import * as appHooks from "@/app/hooks";
|
|
import CalendarLayout from "@/components/Calendar/CalendarLayout";
|
|
import * as calendarUtils from "@/components/Calendar/utils/calendarUtils";
|
|
import * as eventUtils from "@/components/Event/utils/eventUtils";
|
|
import * as CalendarSlice from "@/features/Calendars/CalendarSlice";
|
|
import { Calendar } from "@/features/Calendars/CalendarTypes";
|
|
import * as eventThunks from "@/features/Calendars/services";
|
|
import EventPreviewModal from "@/features/Events/EventDisplayPreview";
|
|
import EventPopover from "@/features/Events/EventModal";
|
|
import { CalendarEvent } from "@/features/Events/EventsTypes";
|
|
import EventUpdateModal from "@/features/Events/EventUpdateModal";
|
|
import * as userApi from "@/features/User/userAPI";
|
|
import { DateSelectArg } from "@fullcalendar/core";
|
|
import { jest } from "@jest/globals";
|
|
import { ThunkDispatch } from "@reduxjs/toolkit";
|
|
import "@testing-library/jest-dom";
|
|
import { act, fireEvent, screen, waitFor } from "@testing-library/react";
|
|
import { SpiedFunction } from "jest-mock";
|
|
import { renderWithProviders } from "../../utils/Renderwithproviders";
|
|
|
|
describe("Update tempcalendars called with correct params", () => {
|
|
const today = new Date();
|
|
const start = new Date(today);
|
|
start.setHours(10, 0, 0, 0);
|
|
const end = new Date(today);
|
|
end.setHours(11, 0, 0, 0);
|
|
|
|
let refreshCalendarsSpy: SpiedFunction<
|
|
(
|
|
dispatch: ThunkDispatch<any, any, any>,
|
|
calendars: Calendar[],
|
|
calendarRange: { start: Date; end: Date },
|
|
calType?: "temp"
|
|
) => Promise<void>
|
|
>;
|
|
let refreshSingularCalendarSpy: SpiedFunction<
|
|
(
|
|
dispatch: ThunkDispatch<any, any, any>,
|
|
calendar: Calendar,
|
|
calendarRange: { start: Date; end: Date },
|
|
calType?: "temp"
|
|
) => Promise<void>
|
|
>;
|
|
let updateTempCalendarSpy: SpiedFunction<
|
|
(
|
|
tempcalendars: Record<string, Calendar>,
|
|
event: CalendarEvent,
|
|
dispatch: ThunkDispatch<any, any, any>,
|
|
calendarRange: { start: Date; end: Date }
|
|
) => Promise<void>
|
|
>;
|
|
|
|
beforeEach(() => {
|
|
jest.clearAllMocks();
|
|
const dispatch = jest.fn((thunk) => {
|
|
if (typeof thunk === "function") {
|
|
return thunk(dispatch, () => ({}), undefined);
|
|
}
|
|
return thunk;
|
|
}) as ThunkDispatch<any, any, any>;
|
|
jest.spyOn(appHooks, "useAppDispatch").mockReturnValue(dispatch);
|
|
refreshCalendarsSpy = jest
|
|
.spyOn(eventUtils, "refreshCalendars")
|
|
.mockResolvedValue();
|
|
updateTempCalendarSpy = jest.spyOn(calendarUtils, "updateTempCalendar");
|
|
refreshSingularCalendarSpy = jest.spyOn(
|
|
eventUtils,
|
|
"refreshSingularCalendar"
|
|
);
|
|
});
|
|
|
|
afterEach(() => {
|
|
refreshCalendarsSpy.mockRestore();
|
|
updateTempCalendarSpy.mockRestore();
|
|
refreshSingularCalendarSpy.mockRestore();
|
|
});
|
|
|
|
const createPreloadedState = (withTempList = true) => ({
|
|
user: {
|
|
userData: {
|
|
sub: "test",
|
|
email: "owner@test.com",
|
|
sid: "mockSid",
|
|
openpaasId: "667037022b752d0026472254",
|
|
},
|
|
organiserData: {
|
|
cn: "Owner",
|
|
cal_address: "owner@test.com",
|
|
},
|
|
tokens: {
|
|
accessToken: "token",
|
|
},
|
|
},
|
|
calendars: {
|
|
list: {
|
|
"667037022b752d0026472254/cal1": {
|
|
name: "Calendar 1",
|
|
id: "667037022b752d0026472254/cal1",
|
|
color: "#FF0000",
|
|
ownerEmails: ["owner@test.com"],
|
|
events: {
|
|
event1: {
|
|
id: "event1",
|
|
calId: "667037022b752d0026472254/cal1",
|
|
uid: "event1",
|
|
title: "Test Event",
|
|
start: start.toISOString(),
|
|
end: end.toISOString(),
|
|
attendee: [{ cal_address: "attendee@test.com" }],
|
|
organizer: {
|
|
cn: "Owner",
|
|
cal_address: "owner@test.com",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
templist: withTempList
|
|
? {
|
|
temp1: {
|
|
id: "temp1",
|
|
name: "Temp Calendar",
|
|
color: "#00FF00",
|
|
events: {},
|
|
ownerEmails: ["attendee@test.com"],
|
|
},
|
|
}
|
|
: undefined,
|
|
pending: false,
|
|
},
|
|
});
|
|
|
|
it("should call updateTempCalendar with correct params after event deletion", async () => {
|
|
const preloadedState = createPreloadedState(true);
|
|
|
|
const mockOnClose = jest.fn();
|
|
renderWithProviders(
|
|
<EventPreviewModal
|
|
eventId="event1"
|
|
calId="667037022b752d0026472254/cal1"
|
|
open={true}
|
|
onClose={mockOnClose}
|
|
/>,
|
|
preloadedState
|
|
);
|
|
|
|
await waitFor(() => {
|
|
fireEvent.click(screen.getByTestId("MoreVertIcon"));
|
|
expect(screen.getByText("eventPreview.deleteEvent")).toBeInTheDocument();
|
|
});
|
|
|
|
const deleteMenuItem = screen.getByText("eventPreview.deleteEvent");
|
|
fireEvent.click(deleteMenuItem);
|
|
|
|
await waitFor(() =>
|
|
expect(updateTempCalendarSpy).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
temp1: expect.objectContaining({ id: "temp1" }),
|
|
}),
|
|
expect.objectContaining({
|
|
attendee: [
|
|
expect.objectContaining({ cal_address: "attendee@test.com" }),
|
|
],
|
|
}),
|
|
expect.any(Function),
|
|
expect.objectContaining({
|
|
start: expect.any(Date),
|
|
end: expect.any(Date),
|
|
})
|
|
)
|
|
);
|
|
|
|
await waitFor(() =>
|
|
expect(refreshSingularCalendarSpy).toHaveBeenCalledWith(
|
|
expect.any(Function),
|
|
expect.objectContaining({ id: "temp1" }),
|
|
expect.objectContaining({
|
|
start: expect.any(Date),
|
|
end: expect.any(Date),
|
|
}),
|
|
"temp"
|
|
)
|
|
);
|
|
});
|
|
|
|
it("should NOT call updateTempCalendar when templist is undefined", async () => {
|
|
const preloadedState = createPreloadedState(false);
|
|
|
|
const mockOnClose = jest.fn();
|
|
renderWithProviders(
|
|
<EventPreviewModal
|
|
eventId="event1"
|
|
calId="667037022b752d0026472254/cal1"
|
|
open={true}
|
|
onClose={mockOnClose}
|
|
/>,
|
|
preloadedState
|
|
);
|
|
|
|
await waitFor(() => {
|
|
fireEvent.click(screen.getByTestId("MoreVertIcon"));
|
|
expect(screen.getByText("eventPreview.deleteEvent")).toBeInTheDocument();
|
|
});
|
|
|
|
const deleteMenuItem = screen.getByText("eventPreview.deleteEvent");
|
|
fireEvent.click(deleteMenuItem);
|
|
|
|
await waitFor(() => {
|
|
expect(updateTempCalendarSpy).not.toHaveBeenCalled();
|
|
expect(refreshSingularCalendarSpy).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
it("should call updateTempCalendar with correct params after event creation", async () => {
|
|
const preloadedState = createPreloadedState(true);
|
|
const defaultSelectedRange = {
|
|
startStr: "2025-07-18T09:00Z",
|
|
endStr: "2025-07-18T10:00Z",
|
|
start: new Date("2025-07-18T09:00Z"),
|
|
end: new Date("2025-07-18T10:00Z"),
|
|
allDay: false,
|
|
resource: undefined,
|
|
} as unknown as DateSelectArg;
|
|
jest.spyOn(userApi, "searchUsers");
|
|
|
|
// Mock putEventAsync to return success with unwrap
|
|
const putEventAsyncMock = jest
|
|
.spyOn(eventThunks, "putEventAsync")
|
|
.mockImplementation((payload) => {
|
|
const action = {
|
|
type: "calendars/putEvent/fulfilled",
|
|
payload: {
|
|
calId: payload.cal.id,
|
|
events: [],
|
|
calType: payload.calType,
|
|
},
|
|
unwrap: () =>
|
|
Promise.resolve({
|
|
calId: payload.cal.id,
|
|
events: [],
|
|
calType: payload.calType,
|
|
}),
|
|
};
|
|
const promise = Promise.resolve(action) as any;
|
|
return () => promise;
|
|
});
|
|
|
|
renderWithProviders(
|
|
<EventPopover
|
|
anchorEl={null}
|
|
open={true}
|
|
onClose={jest.fn()}
|
|
selectedRange={defaultSelectedRange}
|
|
setSelectedRange={jest.fn()}
|
|
calendarRef={{ current: null }}
|
|
/>,
|
|
preloadedState
|
|
);
|
|
|
|
await waitFor(() => {
|
|
expect(screen.getByRole("dialog")).toBeInTheDocument();
|
|
});
|
|
|
|
const titleInput = screen.getByLabelText(/title/i);
|
|
fireEvent.change(titleInput, { target: { value: "New Event" } });
|
|
|
|
const attendeeInput = screen.getByLabelText(/peopleSearch.label/i);
|
|
fireEvent.change(attendeeInput, { target: { value: "attendee@test.com" } });
|
|
fireEvent.keyDown(attendeeInput, { key: "Enter", code: "Enter" });
|
|
|
|
const saveButton = screen.getByText(/save/i);
|
|
await act(async () => {
|
|
fireEvent.click(saveButton);
|
|
});
|
|
|
|
await waitFor(
|
|
() =>
|
|
expect(updateTempCalendarSpy).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
temp1: expect.objectContaining({ id: "temp1" }),
|
|
}),
|
|
expect.objectContaining({
|
|
title: "New Event",
|
|
}),
|
|
expect.any(Function),
|
|
expect.objectContaining({
|
|
start: expect.any(Date),
|
|
end: expect.any(Date),
|
|
})
|
|
),
|
|
{ timeout: 3000 }
|
|
);
|
|
|
|
await waitFor(() =>
|
|
expect(refreshSingularCalendarSpy).toHaveBeenCalledWith(
|
|
expect.any(Function),
|
|
expect.objectContaining({ id: "temp1" }),
|
|
expect.objectContaining({
|
|
start: expect.any(Date),
|
|
end: expect.any(Date),
|
|
}),
|
|
"temp"
|
|
)
|
|
);
|
|
});
|
|
|
|
it("should call updateTempCalendar with correct params after event update", async () => {
|
|
const preloadedState = createPreloadedState(true);
|
|
|
|
const mockOnClose = jest.fn();
|
|
renderWithProviders(
|
|
<EventUpdateModal
|
|
open={true}
|
|
onClose={mockOnClose}
|
|
eventId="event1"
|
|
calId="667037022b752d0026472254/cal1"
|
|
/>,
|
|
preloadedState
|
|
);
|
|
|
|
await waitFor(() => {
|
|
expect(screen.getByRole("dialog")).toBeInTheDocument();
|
|
});
|
|
|
|
const saveButton = screen.getByText(/save/i);
|
|
fireEvent.click(saveButton);
|
|
|
|
await waitFor(() =>
|
|
expect(updateTempCalendarSpy).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
temp1: expect.objectContaining({ id: "temp1" }),
|
|
}),
|
|
expect.objectContaining({
|
|
attendee: [
|
|
expect.objectContaining({ cal_address: "attendee@test.com" }),
|
|
],
|
|
}),
|
|
expect.any(Function),
|
|
expect.objectContaining({
|
|
start: expect.any(Date),
|
|
end: expect.any(Date),
|
|
})
|
|
)
|
|
);
|
|
|
|
await waitFor(() =>
|
|
expect(refreshSingularCalendarSpy).toHaveBeenCalledWith(
|
|
expect.any(Function),
|
|
expect.objectContaining({ id: "temp1" }),
|
|
expect.objectContaining({
|
|
start: expect.any(Date),
|
|
end: expect.any(Date),
|
|
}),
|
|
"temp"
|
|
)
|
|
);
|
|
});
|
|
|
|
it("should call updateTempCalendar with correct params after recurring event instance update", async () => {
|
|
const preloadedStateWithRecurring = {
|
|
...createPreloadedState(true),
|
|
calendars: {
|
|
...createPreloadedState(true).calendars,
|
|
list: {
|
|
"667037022b752d0026472254/cal1": {
|
|
name: "Calendar 1",
|
|
id: "667037022b752d0026472254/cal1",
|
|
color: "#FF0000",
|
|
ownerEmails: ["owner@test.com"],
|
|
events: {
|
|
event1: {
|
|
id: "event1",
|
|
calId: "667037022b752d0026472254/cal1",
|
|
uid: "event1",
|
|
title: "Recurring Event",
|
|
start: start.toISOString(),
|
|
end: end.toISOString(),
|
|
attendee: [{ cal_address: "attendee@test.com" }],
|
|
rrule: {
|
|
freq: "WEEKLY",
|
|
},
|
|
organizer: {
|
|
cn: "Owner",
|
|
cal_address: "owner@test.com",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
};
|
|
|
|
const mockOnClose = jest.fn();
|
|
renderWithProviders(
|
|
<EventUpdateModal
|
|
open={true}
|
|
onClose={mockOnClose}
|
|
eventId="event1"
|
|
calId="667037022b752d0026472254/cal1"
|
|
typeOfAction="solo"
|
|
/>,
|
|
preloadedStateWithRecurring
|
|
);
|
|
|
|
await waitFor(() => {
|
|
expect(screen.getByRole("dialog")).toBeInTheDocument();
|
|
});
|
|
|
|
const saveButton = screen.getByText(/save/i);
|
|
fireEvent.click(saveButton);
|
|
|
|
await waitFor(() =>
|
|
expect(updateTempCalendarSpy).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
temp1: expect.objectContaining({ id: "temp1" }),
|
|
}),
|
|
expect.objectContaining({
|
|
attendee: [
|
|
expect.objectContaining({ cal_address: "attendee@test.com" }),
|
|
],
|
|
}),
|
|
expect.any(Function),
|
|
expect.objectContaining({
|
|
start: expect.any(Date),
|
|
end: expect.any(Date),
|
|
})
|
|
)
|
|
);
|
|
|
|
await waitFor(() =>
|
|
expect(refreshSingularCalendarSpy).toHaveBeenCalledWith(
|
|
expect.any(Function),
|
|
expect.objectContaining({ id: "temp1" }),
|
|
expect.objectContaining({
|
|
start: expect.any(Date),
|
|
end: expect.any(Date),
|
|
}),
|
|
"temp"
|
|
)
|
|
);
|
|
});
|
|
|
|
it("should call updateTempCalendar with correct params after recurring series update", async () => {
|
|
const preloadedStateWithRecurring = {
|
|
...createPreloadedState(true),
|
|
calendars: {
|
|
...createPreloadedState(true).calendars,
|
|
list: {
|
|
"667037022b752d0026472254/cal1": {
|
|
name: "Calendar 1",
|
|
id: "667037022b752d0026472254/cal1",
|
|
color: "#FF0000",
|
|
ownerEmails: ["owner@test.com"],
|
|
events: {
|
|
event1: {
|
|
id: "event1",
|
|
calId: "667037022b752d0026472254/cal1",
|
|
uid: "event1",
|
|
title: "Recurring Event",
|
|
start: start.toISOString(),
|
|
end: end.toISOString(),
|
|
attendee: [{ cal_address: "attendee@test.com" }],
|
|
rrule: {
|
|
freq: "DAILY",
|
|
},
|
|
organizer: {
|
|
cn: "Owner",
|
|
cal_address: "owner@test.com",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
};
|
|
|
|
const mockOnClose = jest.fn();
|
|
renderWithProviders(
|
|
<EventUpdateModal
|
|
open={true}
|
|
onClose={mockOnClose}
|
|
eventId="event1"
|
|
calId="667037022b752d0026472254/cal1"
|
|
typeOfAction="all"
|
|
/>,
|
|
preloadedStateWithRecurring
|
|
);
|
|
|
|
await waitFor(() => {
|
|
expect(screen.getByRole("dialog")).toBeInTheDocument();
|
|
});
|
|
|
|
const saveButton = screen.getByText(/save/i);
|
|
fireEvent.click(saveButton);
|
|
|
|
await waitFor(() =>
|
|
expect(updateTempCalendarSpy).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
temp1: expect.objectContaining({ id: "temp1" }),
|
|
}),
|
|
expect.objectContaining({
|
|
attendee: [
|
|
expect.objectContaining({ cal_address: "attendee@test.com" }),
|
|
],
|
|
}),
|
|
expect.any(Function),
|
|
expect.objectContaining({
|
|
start: expect.any(Date),
|
|
end: expect.any(Date),
|
|
})
|
|
)
|
|
);
|
|
|
|
await waitFor(() =>
|
|
expect(refreshSingularCalendarSpy).toHaveBeenCalledWith(
|
|
expect.any(Function),
|
|
expect.objectContaining({ id: "temp1" }),
|
|
expect.objectContaining({
|
|
start: expect.any(Date),
|
|
end: expect.any(Date),
|
|
}),
|
|
"temp"
|
|
)
|
|
);
|
|
});
|
|
|
|
it("should call refreshCalendars with 'temp' param in CalendarLayout handleRefresh", async () => {
|
|
const preloadedState = createPreloadedState(true);
|
|
|
|
renderWithProviders(<CalendarLayout />, preloadedState);
|
|
|
|
fireEvent.click(screen.getByTestId("RefreshIcon"));
|
|
|
|
await waitFor(() => {
|
|
// Should call refreshCalendars for regular calendars
|
|
expect(refreshCalendarsSpy).toHaveBeenCalledWith(
|
|
expect.any(Function),
|
|
expect.any(Array),
|
|
expect.objectContaining({
|
|
start: expect.any(Date),
|
|
end: expect.any(Date),
|
|
})
|
|
);
|
|
|
|
// Should also call refreshCalendars with 'temp' for templist
|
|
expect(refreshCalendarsSpy).toHaveBeenCalledWith(
|
|
expect.any(Function),
|
|
expect.arrayContaining([expect.objectContaining({ id: "temp1" })]),
|
|
expect.objectContaining({
|
|
start: expect.any(Date),
|
|
end: expect.any(Date),
|
|
}),
|
|
"temp"
|
|
);
|
|
});
|
|
});
|
|
|
|
it("should only refresh temp calendars where attendees match ownerEmails", async () => {
|
|
const preloadedStateMultipleTempCals = {
|
|
...createPreloadedState(true),
|
|
calendars: {
|
|
...createPreloadedState(true).calendars,
|
|
templist: {
|
|
temp1: {
|
|
id: "temp1",
|
|
name: "Temp Calendar 1",
|
|
color: "#00FF00",
|
|
events: {},
|
|
ownerEmails: ["attendee@test.com"], // matches event attendee
|
|
},
|
|
temp2: {
|
|
id: "temp2",
|
|
name: "Temp Calendar 2",
|
|
color: "#0000FF",
|
|
events: {},
|
|
ownerEmails: ["other@test.com"], // does NOT match event attendee
|
|
},
|
|
},
|
|
},
|
|
};
|
|
|
|
const mockOnClose = jest.fn();
|
|
renderWithProviders(
|
|
<EventPreviewModal
|
|
eventId="event1"
|
|
calId="667037022b752d0026472254/cal1"
|
|
open={true}
|
|
onClose={mockOnClose}
|
|
/>,
|
|
preloadedStateMultipleTempCals
|
|
);
|
|
|
|
await waitFor(() => {
|
|
fireEvent.click(screen.getByTestId("MoreVertIcon"));
|
|
expect(screen.getByText("eventPreview.deleteEvent")).toBeInTheDocument();
|
|
});
|
|
|
|
const deleteMenuItem = screen.getByText("eventPreview.deleteEvent");
|
|
fireEvent.click(deleteMenuItem);
|
|
|
|
await waitFor(() => {
|
|
// Should only refresh temp1, not temp2
|
|
const temp1Calls = refreshSingularCalendarSpy.mock.calls.filter(
|
|
(call) => call[1]?.id === "temp1"
|
|
);
|
|
const temp2Calls = refreshSingularCalendarSpy.mock.calls.filter(
|
|
(call) => call[1]?.id === "temp2"
|
|
);
|
|
|
|
expect(temp1Calls.length).toBeGreaterThan(0);
|
|
expect(temp2Calls.length).toBe(0);
|
|
});
|
|
});
|
|
|
|
it("should call emptyEventsCal with correct params before refreshing", async () => {
|
|
const emptyEventsCalSpy = jest.spyOn(CalendarSlice, "emptyEventsCal");
|
|
|
|
const preloadedState = createPreloadedState(true);
|
|
|
|
const mockOnClose = jest.fn();
|
|
renderWithProviders(
|
|
<EventPreviewModal
|
|
eventId="event1"
|
|
calId="667037022b752d0026472254/cal1"
|
|
open={true}
|
|
onClose={mockOnClose}
|
|
/>,
|
|
preloadedState
|
|
);
|
|
|
|
await waitFor(() => {
|
|
fireEvent.click(screen.getByTestId("MoreVertIcon"));
|
|
expect(screen.getByText("eventPreview.deleteEvent")).toBeInTheDocument();
|
|
});
|
|
|
|
const deleteMenuItem = screen.getByText("eventPreview.deleteEvent");
|
|
fireEvent.click(deleteMenuItem);
|
|
|
|
await waitFor(() => {
|
|
// emptyEventsCal should be called with calType: "temp" for singular calendar refresh
|
|
expect(emptyEventsCalSpy).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
calId: "temp1",
|
|
calType: "temp",
|
|
})
|
|
);
|
|
});
|
|
|
|
emptyEventsCalSpy.mockRestore();
|
|
});
|
|
|
|
it("should handle temp calendar with multiple ownerEmails where one matches", async () => {
|
|
const preloadedStateMultipleOwners = {
|
|
...createPreloadedState(true),
|
|
calendars: {
|
|
...createPreloadedState(true).calendars,
|
|
list: {
|
|
"667037022b752d0026472254/cal1": {
|
|
name: "Calendar 1",
|
|
id: "667037022b752d0026472254/cal1",
|
|
color: "#FF0000",
|
|
ownerEmails: ["owner@test.com"],
|
|
events: {
|
|
event1: {
|
|
id: "event1",
|
|
calId: "667037022b752d0026472254/cal1",
|
|
uid: "event1",
|
|
title: "Test Event",
|
|
start: start.toISOString(),
|
|
end: end.toISOString(),
|
|
attendee: [{ cal_address: "attendee@test.com" }],
|
|
organizer: {
|
|
cn: "Owner",
|
|
cal_address: "owner@test.com",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
templist: {
|
|
temp1: {
|
|
id: "temp1",
|
|
name: "Shared Calendar",
|
|
color: "#00FF00",
|
|
events: {},
|
|
ownerEmails: [
|
|
"someoneelse@test.com",
|
|
"attendee@test.com", // matches
|
|
"anotherperson@test.com",
|
|
],
|
|
},
|
|
},
|
|
},
|
|
};
|
|
|
|
const mockOnClose = jest.fn();
|
|
renderWithProviders(
|
|
<EventPreviewModal
|
|
eventId="event1"
|
|
calId="667037022b752d0026472254/cal1"
|
|
open={true}
|
|
onClose={mockOnClose}
|
|
/>,
|
|
preloadedStateMultipleOwners
|
|
);
|
|
|
|
await waitFor(() => {
|
|
fireEvent.click(screen.getByTestId("MoreVertIcon"));
|
|
expect(screen.getByText("eventPreview.deleteEvent")).toBeInTheDocument();
|
|
});
|
|
|
|
const deleteMenuItem = screen.getByText("eventPreview.deleteEvent");
|
|
fireEvent.click(deleteMenuItem);
|
|
|
|
await waitFor(() => {
|
|
// Should still refresh temp1 because one ownerEmail matches
|
|
const temp1Calls = refreshSingularCalendarSpy.mock.calls.filter(
|
|
(call) => call[1]?.id === "temp1"
|
|
);
|
|
|
|
expect(temp1Calls.length).toBeGreaterThan(0);
|
|
expect(temp1Calls[0][3]).toBe("temp");
|
|
});
|
|
});
|
|
it("should update multiple temp calendars when event has multiple attendees matching different ownerEmails", async () => {
|
|
const preloadedStateMultipleAttendees = {
|
|
...createPreloadedState(true),
|
|
calendars: {
|
|
...createPreloadedState(true).calendars,
|
|
list: {
|
|
"667037022b752d0026472254/cal1": {
|
|
name: "Calendar 1",
|
|
id: "667037022b752d0026472254/cal1",
|
|
color: "#FF0000",
|
|
ownerEmails: ["owner@test.com"],
|
|
events: {
|
|
event1: {
|
|
id: "event1",
|
|
calId: "667037022b752d0026472254/cal1",
|
|
uid: "event1",
|
|
title: "Test Event",
|
|
start: start.toISOString(),
|
|
end: end.toISOString(),
|
|
attendee: [
|
|
{ cal_address: "attendee1@test.com" },
|
|
{ cal_address: "attendee2@test.com" },
|
|
{ cal_address: "attendee3@test.com" },
|
|
],
|
|
organizer: {
|
|
cn: "Owner",
|
|
cal_address: "owner@test.com",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
templist: {
|
|
temp1: {
|
|
id: "temp1",
|
|
name: "Temp Calendar 1",
|
|
color: "#00FF00",
|
|
events: {},
|
|
ownerEmails: ["attendee1@test.com"],
|
|
},
|
|
temp2: {
|
|
id: "temp2",
|
|
name: "Temp Calendar 2",
|
|
color: "#0000FF",
|
|
events: {},
|
|
ownerEmails: ["attendee2@test.com"],
|
|
},
|
|
temp3: {
|
|
id: "temp3",
|
|
name: "Temp Calendar 3",
|
|
color: "#FF00FF",
|
|
events: {},
|
|
ownerEmails: ["attendee3@test.com"],
|
|
},
|
|
temp4: {
|
|
id: "temp4",
|
|
name: "Temp Calendar 4",
|
|
color: "#FFFF00",
|
|
events: {},
|
|
ownerEmails: ["nonmatching@test.com"], // should NOT be refreshed
|
|
},
|
|
},
|
|
},
|
|
};
|
|
|
|
const mockOnClose = jest.fn();
|
|
renderWithProviders(
|
|
<EventPreviewModal
|
|
eventId="event1"
|
|
calId="667037022b752d0026472254/cal1"
|
|
open={true}
|
|
onClose={mockOnClose}
|
|
/>,
|
|
preloadedStateMultipleAttendees
|
|
);
|
|
|
|
await waitFor(() => {
|
|
fireEvent.click(screen.getByTestId("MoreVertIcon"));
|
|
expect(screen.getByText("eventPreview.deleteEvent")).toBeInTheDocument();
|
|
});
|
|
|
|
const deleteMenuItem = screen.getByText("eventPreview.deleteEvent");
|
|
fireEvent.click(deleteMenuItem);
|
|
|
|
await waitFor(() => {
|
|
// Should be called once with all templist
|
|
expect(updateTempCalendarSpy).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
temp1: expect.objectContaining({ id: "temp1" }),
|
|
temp2: expect.objectContaining({ id: "temp2" }),
|
|
temp3: expect.objectContaining({ id: "temp3" }),
|
|
temp4: expect.objectContaining({ id: "temp4" }),
|
|
}),
|
|
expect.objectContaining({
|
|
attendee: expect.arrayContaining([
|
|
expect.objectContaining({ cal_address: "attendee1@test.com" }),
|
|
expect.objectContaining({ cal_address: "attendee2@test.com" }),
|
|
expect.objectContaining({ cal_address: "attendee3@test.com" }),
|
|
]),
|
|
}),
|
|
expect.any(Function),
|
|
expect.objectContaining({
|
|
start: expect.any(Date),
|
|
end: expect.any(Date),
|
|
})
|
|
);
|
|
});
|
|
|
|
await waitFor(() => {
|
|
// Should refresh temp1, temp2, and temp3 (matching attendees)
|
|
const temp1Calls = refreshSingularCalendarSpy.mock.calls.filter(
|
|
(call) => call[1]?.id === "temp1"
|
|
);
|
|
const temp2Calls = refreshSingularCalendarSpy.mock.calls.filter(
|
|
(call) => call[1]?.id === "temp2"
|
|
);
|
|
const temp3Calls = refreshSingularCalendarSpy.mock.calls.filter(
|
|
(call) => call[1]?.id === "temp3"
|
|
);
|
|
const temp4Calls = refreshSingularCalendarSpy.mock.calls.filter(
|
|
(call) => call[1]?.id === "temp4"
|
|
);
|
|
|
|
expect(temp1Calls.length).toBeGreaterThan(0);
|
|
expect(temp2Calls.length).toBeGreaterThan(0);
|
|
expect(temp3Calls.length).toBeGreaterThan(0);
|
|
expect(temp4Calls.length).toBe(0); // Should NOT be refreshed
|
|
|
|
// Verify all matching calendars were refreshed with 'temp' param
|
|
expect(temp1Calls[0][3]).toBe("temp");
|
|
expect(temp2Calls[0][3]).toBe("temp");
|
|
expect(temp3Calls[0][3]).toBe("temp");
|
|
});
|
|
});
|
|
});
|