workavia-calendar-front/__test__/utils/calendarUtils.test.tsx

import {
  eventToFullCalendarFormat,
  getCalendarVisibility
} from '@/components/Calendar/utils/calendarUtils'
import { Calendar, DelegationAccess } from '@/features/Calendars/CalendarTypes'
import { AclEntry } from '@/features/Calendars/types/CalendarData'
import { CalendarEvent } from '@/features/Events/EventsTypes'
import { userOrganiser } from '@/features/User/userDataTypes'

describe('getCalendarVisibility', () => {
  it("returns 'public' when {DAV:}authenticated has {DAV:}read", () => {
    const acl: AclEntry[] = [
      {
        privilege: '{DAV:}read',
        principal: '{DAV:}authenticated',
        protected: true
      }
    ]
    expect(getCalendarVisibility(acl)).toBe('public')
  })

  it("returns 'private' when {DAV:}authenticated only has read-free-busy", () => {
    const acl: AclEntry[] = [
      {
        privilege: '{urn:ietf:params:xml:ns:caldav}read-free-busy',
        principal: '{DAV:}authenticated',
        protected: true
      }
    ]
    expect(getCalendarVisibility(acl)).toBe('private')
  })

  it("returns 'private' when {DAV:}authenticated is not present", () => {
    const acl: AclEntry[] = [
      {
        privilege: '{DAV:}read',
        principal: 'principals/users/123',
        protected: true
      }
    ]
    expect(getCalendarVisibility(acl)).toBe('private')
  })

  it("ignores non-authenticated principals and still returns 'private'", () => {
    const acl: AclEntry[] = [
      {
        privilege: '{DAV:}read',
        principal: 'principals/users/other',
        protected: true
      },
      {
        privilege: '{DAV:}write',
        principal: 'principals/users/other',
        protected: true
      }
    ]
    expect(getCalendarVisibility(acl)).toBe('private')
  })

  it('stops early when it finds a {DAV:}read for {DAV:}authenticated', () => {
    const acl: AclEntry[] = [
      {
        privilege: '{DAV:}read',
        principal: '{DAV:}authenticated',
        protected: true
      },
      {
        privilege: '{DAV:}write',
        principal: '{DAV:}authenticated',
        protected: true
      }
    ]
    expect(getCalendarVisibility(acl)).toBe('public')
  })
})

jest.mock('twake-i18n', () => ({
  useI18n: () => ({ t: (key: string) => key })
}))

const baseEvent: CalendarEvent = {
  uid: 'event-1',
  calId: 'user1/cal1',
  title: 'Test Event',
  start: '2024-01-15T10:00:00',
  end: '2024-01-15T11:00:00',
  allday: false,
  organizer: { cal_address: 'owner@example.com' } as userOrganiser,
  color: { light: '#FF0000' },
  class: 'PUBLIC'
} as unknown as CalendarEvent

const makeCalendar = (overrides: Partial<Calendar> = {}): Calendar =>
  ({
    id: 'user1/cal1',
    name: 'Test Calendar',
    delegated: false,
    access: {} as DelegationAccess,
    owner: { emails: ['alice@example.com'], firstname: 'Alice' },
    color: { light: '#FF0000' },
    events: {},
    ...overrides
  }) as Calendar

const callFormat = (
  event: CalendarEvent,
  calendars: Record<string, Calendar>,
  userAddress = 'alice@example.com',
  userId = 'user1'
) =>
  eventToFullCalendarFormat([event], [], userId, userAddress, false, calendars)

describe('eventToFullCalendarFormat - editable flag', () => {
  describe('personal calendar (non-delegated)', () => {
    const calendar = makeCalendar({ delegated: false })

    it('is editable when user is organizer', () => {
      const event = {
        ...baseEvent,
        organizer: { cal_address: 'alice@example.com' }
      } as CalendarEvent
      const [result] = callFormat(event, { 'user1/cal1': calendar })
      expect(result.editable).toBe(true)
    })

    it('is not editable when user is not organizer', () => {
      const event = {
        ...baseEvent,
        organizer: { cal_address: 'other@example.com' }
      } as CalendarEvent
      const [result] = callFormat(event, { 'user1/cal1': calendar })
      expect(result.editable).toBe(false)
    })

    it('is not editable when pending', () => {
      const event = {
        ...baseEvent,
        organizer: { cal_address: 'alice@example.com' }
      } as CalendarEvent
      const [result] = eventToFullCalendarFormat(
        [event],
        [],
        'user1',
        'alice@example.com',
        true,
        { 'user1/cal1': calendar }
      )
      expect(result.editable).toBe(false)
    })
  })

  describe('delegated calendar', () => {
    const writeDelegatedCalendar = makeCalendar({
      id: 'user2/cal1',
      delegated: true,
      access: { write: true } as DelegationAccess,
      owner: { emails: ['owner@example.com'], firstname: 'Owner' }
    })
    const readDelegatedCalendar = makeCalendar({
      id: 'user2/cal1',
      delegated: true,
      access: { read: true } as DelegationAccess,
      owner: { emails: ['owner@example.com'], firstname: 'Owner' }
    })
    const event = { ...baseEvent, calId: 'user2/cal1' }

    it('is editable when owner is organizer and delegated user has write rights', () => {
      const [result] = callFormat(
        {
          ...event,
          organizer: { cal_address: 'owner@example.com' }
        } as CalendarEvent,
        { 'user2/cal1': writeDelegatedCalendar }
      )
      expect(result.editable).toBe(true)
    })

    it('is not editable when owner is organizer but delegated user only has read access', () => {
      const [result] = callFormat(
        {
          ...event,
          organizer: { cal_address: 'owner@example.com' }
        } as CalendarEvent,
        { 'user2/cal1': readDelegatedCalendar }
      )
      expect(result.editable).toBe(false)
    })

    it('is not editable when owner is not organizer', () => {
      const [result] = callFormat(
        {
          ...event,
          organizer: { cal_address: 'someone-else@example.com' }
        } as CalendarEvent,
        { 'user2/cal1': writeDelegatedCalendar }
      )
      expect(result.editable).toBe(false)
    })

    it('is not editable when pending even if owner is organizer', () => {
      const [result] = eventToFullCalendarFormat(
        [
          {
            ...event,
            organizer: { cal_address: 'owner@example.com' }
          } as CalendarEvent
        ],
        [],
        'user1',
        'alice@example.com',
        true,
        { 'user2/cal1': writeDelegatedCalendar }
      )
      expect(result.editable).toBe(false)
    })

    it('uses owner email not logged-in user email for organizer check', () => {
      // logged-in user is alice, owner is owner@example.com
      // organizer matches owner → editable
      const [result] = callFormat(
        {
          ...event,
          organizer: { cal_address: 'owner@example.com' }
        } as CalendarEvent,
        { 'user2/cal1': writeDelegatedCalendar },
        'alice@example.com' // logged-in user, should NOT be used for delegated
      )
      expect(result.editable).toBe(true)
    })
  })
})