workavia-calendar-front/__test__/features/Events/AttendanceValidation.delegated.test.tsx

import { Calendar } from '@/features/Calendars/CalendarTypes'
import { AttendanceValidation } from '@/features/Events/AttendanceValidation/AttendanceValidation'
import { ContextualizedEvent } from '@/features/Events/EventsTypes'
import { userAttendee } from '@/features/User/models/attendee'
import { userData } from '@/features/User/userDataTypes'
import { render } from '@testing-library/react'

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

jest.mock('@/app/hooks', () => ({
  useAppDispatch: () => jest.fn(),
  useAppSelector: jest.fn()
}))

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

const makeContext = (
  overrides: Partial<ContextualizedEvent> = {}
): ContextualizedEvent =>
  ({
    event: {
      uid: 'event-1',
      calId: 'user1/cal1',
      title: 'Test',
      start: '2024-01-15T10:00:00',
      end: '2024-01-15T11:00:00',
      organizer: { cal_address: 'owner@example.com' },
      attendee: [{ cal_address: 'owner@example.com', partstat: 'NEEDS-ACTION' }]
    },
    calendar: {
      id: 'user1/cal1',
      name: 'Test',
      delegated: false,
      owner: { emails: ['alice@example.com'] },
      events: {}
    },
    currentUserAttendee: {
      cal_address: 'alice@example.com',
      partstat: 'NEEDS-ACTION'
    },
    isOwn: true,
    isOrganizer: false,
    isRecurring: false,
    ...overrides
  }) as unknown as ContextualizedEvent

const noopSetFunc = jest.fn()

describe('AttendanceValidation - delegation', () => {
  describe('non-delegated calendar', () => {
    it('renders when isOwn and currentUserAttendee exists', () => {
      const { container } = render(
        <AttendanceValidation
          contextualizedEvent={makeContext({ isOwn: true })}
          user={makeUser('alice@example.com')}
          setAfterChoiceFunc={noopSetFunc}
          setOpenEditModePopup={noopSetFunc}
        />
      )
      expect(container.firstChild).not.toBeNull()
    })

    it('returns null when not isOwn and not delegated', () => {
      const { container } = render(
        <AttendanceValidation
          contextualizedEvent={makeContext({ isOwn: false })}
          user={makeUser('other@example.com')}
          setAfterChoiceFunc={noopSetFunc}
          setOpenEditModePopup={noopSetFunc}
        />
      )
      expect(container.firstChild).toBeNull()
    })
  })

  describe('delegated calendar', () => {
    const delegatedContext = makeContext({
      isOwn: false, // logged-in user is not the owner
      calendar: {
        id: 'user2/cal1',
        name: 'Delegated Cal',
        delegated: true,
        owner: { emails: ['owner@example.com'] },
        events: {}
      } as Calendar,
      currentUserAttendee: {
        cal_address: 'owner@example.com',
        partstat: 'NEEDS-ACTION'
      } as userAttendee,
      event: { class: 'PUBLIC' }
    })

    it('renders even when isOwn is false', () => {
      const { container } = render(
        <AttendanceValidation
          contextualizedEvent={delegatedContext}
          user={makeUser('alice@example.com')}
          setAfterChoiceFunc={noopSetFunc}
          setOpenEditModePopup={noopSetFunc}
        />
      )
      expect(container.firstChild).not.toBeNull()
    })

    it('renders regardless of currentUserAttendee presence', () => {
      const { container } = render(
        <AttendanceValidation
          contextualizedEvent={{
            ...delegatedContext,
            currentUserAttendee: undefined
          }}
          user={makeUser('alice@example.com')}
          setAfterChoiceFunc={noopSetFunc}
          setOpenEditModePopup={noopSetFunc}
        />
      )
      // delegated flag alone should keep it visible
      expect(container.firstChild).not.toBeNull()
    })
  })

  describe('resource calendar', () => {
    const resourceContext = makeContext({
      isOwn: false,
      calendar: {
        id: 'res1/cal1',
        name: 'Resource Cal',
        delegated: false,
        owner: {
          emails: ['resource@example.com'],
          resource: true,
          administrators: [{ id: 'admin1' }]
        },
        events: {}
      } as Calendar
    })

    it('renders when user is an administrator of the resource', () => {
      const { getByText } = render(
        <AttendanceValidation
          contextualizedEvent={resourceContext}
          user={
            {
              ...makeUser('admin@example.com'),
              openpaasId: 'admin1'
            } as userData
          }
          setAfterChoiceFunc={noopSetFunc}
          setOpenEditModePopup={noopSetFunc}
        />
      )
      expect(getByText('eventPreview.authorizeQuestion')).toBeTruthy()
    })

    it('returns null when user is not an administrator of the resource', () => {
      const { container } = render(
        <AttendanceValidation
          contextualizedEvent={resourceContext}
          user={
            {
              ...makeUser('other@example.com'),
              openpaasId: 'other1'
            } as userData
          }
          setAfterChoiceFunc={noopSetFunc}
          setOpenEditModePopup={noopSetFunc}
        />
      )
      expect(container.firstChild).toBeNull()
    })
  })
})