workavia-calendar-front/__test__/utils/createEventContext.test.ts

import { createEventContext } from "@/features/Events/createEventContext";
import { Calendar } from "@/features/Calendars/CalendarTypes";
import { CalendarEvent } from "@/features/Events/EventsTypes";
import { userData } from "@/features/User/userDataTypes";
import { userAttendee } from "@/features/User/models/attendee";

const makeUser = (email: string): userData => ({
  email,
  given_name: "Alice",
  family_name: "User",
  name: "Alice User",
  sid: "user1",
  sub: "user1",
});

const makeEvent = (overrides: Partial<CalendarEvent> = {}): CalendarEvent =>
  ({
    uid: "event-1",
    calId: "user1/cal1",
    title: "Test Event",
    start: "2024-01-15T10:00:00",
    end: "2024-01-15T11:00:00",
    organizer: { cal_address: "alice@example.com" },
    attendee: [
      { cal_address: "alice@example.com", partstat: "ACCEPTED" },
      { cal_address: "owner@example.com", partstat: "ACCEPTED" },
      { cal_address: "other@example.com", partstat: "NEEDS-ACTION" },
    ],
    ...overrides,
  }) as CalendarEvent;

const makeCalendar = (overrides: Partial<Calendar> = {}): Calendar =>
  ({
    id: "user1/cal1",
    name: "Test Calendar",
    delegated: false,
    owner: { emails: ["alice@example.com"], firstname: "Alice" },
    events: {},
    ...overrides,
  }) as Calendar;

describe("createEventContext", () => {
  describe("non-delegated calendar", () => {
    const calendar = makeCalendar({ delegated: false });
    const user = makeUser("alice@example.com");

    it("finds currentUserAttendee by logged-in user email", () => {
      const event = makeEvent();
      const ctx = createEventContext(event, calendar, user);
      expect(ctx.currentUserAttendee?.cal_address).toBe("alice@example.com");
    });

    it("returns null currentUserAttendee when user is not an attendee", () => {
      const event = makeEvent({ attendee: [] });
      const ctx = createEventContext(event, calendar, user);
      expect(ctx.currentUserAttendee).toBeUndefined();
    });

    it("isOwn is true when user email is in owner emails", () => {
      const ctx = createEventContext(makeEvent(), calendar, user);
      expect(ctx.isOwn).toBe(true);
    });

    it("isOwn is false when user email is not in owner emails", () => {
      const other = makeUser("other@example.com");
      const ctx = createEventContext(makeEvent(), calendar, other);
      expect(ctx.isOwn).toBe(false);
    });
  });

  describe("delegated calendar", () => {
    const calendar = makeCalendar({
      id: "user2/cal1",
      delegated: true,
      owner: { emails: ["owner@example.com"], firstname: "Owner" },
    });
    const user = makeUser("alice@example.com"); // logged-in user, not the owner

    it("finds currentUserAttendee by owner email, not logged-in user email", () => {
      const event = makeEvent({ calId: "user2/cal1" });
      const ctx = createEventContext(event, calendar, user);
      expect(ctx.currentUserAttendee?.cal_address).toBe("owner@example.com");
    });

    it("does not find logged-in user as attendee for delegated calendar", () => {
      const event = makeEvent({
        calId: "user2/cal1",
        attendee: [
          {
            cal_address: "owner@example.com",
            partstat: "ACCEPTED",
          } as userAttendee,
        ],
      });
      const ctx = createEventContext(event, calendar, user);
      // currentUserAttendee should be owner's, not alice's
      expect(ctx.currentUserAttendee?.cal_address).toBe("owner@example.com");
    });

    it("returns undefined currentUserAttendee when owner is not an attendee", () => {
      const event = makeEvent({
        calId: "user2/cal1",
        attendee: [
          {
            cal_address: "alice@example.com",
            partstat: "ACCEPTED",
          } as userAttendee,
        ],
      });
      const ctx = createEventContext(event, calendar, user);
      expect(ctx.currentUserAttendee).toBeUndefined();
    });

    it("passes event through unchanged", () => {
      const event = makeEvent({ calId: "user2/cal1" });
      const ctx = createEventContext(event, calendar, user);
      expect(ctx.event).toBe(event);
    });
  });
});