Merge branch 'main' into copilot/expand-global-search-feature

Author: Starefossen

.github/workflows/copilot-setup-steps.yml

@@ -46,6 +46,3 @@ jobs:
 
       - name: Install dependencies
         run: pnpm install --frozen-lockfile
-
-      - name: Install Playwright browsers
-        run: pnpm exec playwright install --with-deps chromium

__tests__/api/trpc/error-handler.test.ts

@@ -0,0 +1,26 @@
+vi.mock('@/lib/auth', () => ({
+  getAuthSession: vi.fn().mockResolvedValue(null),
+}))
+
+import { isClientError } from '@/server/trpc'
+
+describe('tRPC error handler', () => {
+  describe('isClientError', () => {
+    it.each([
+      'NOT_FOUND',
+      'BAD_REQUEST',
+      'UNAUTHORIZED',
+      'FORBIDDEN',
+      'PARSE_ERROR',
+    ])('should classify %s as a client error', (code) => {
+      expect(isClientError(code)).toBe(true)
+    })
+
+    it.each(['INTERNAL_SERVER_ERROR', 'TIMEOUT', 'TOO_MANY_REQUESTS'])(
+      'should not classify %s as a client error',
+      (code) => {
+        expect(isClientError(code)).toBe(false)
+      },
+    )
+  })
+})

__tests__/components/admin/sponsor-crm/SponsorContractView.test.tsx

@@ -141,10 +141,20 @@ describe('SponsorContractView', () => {
     })
 
     it('shows portal section when registration not complete', () => {
-      renderView({ registrationComplete: false })
+      renderView({ registrationComplete: false, status: 'closed-won' })
       expect(screen.getByTestId('portal-section')).toBeInTheDocument()
     })
 
+    it('shows warning instead of portal when sponsor is not closed-won', () => {
+      renderView({ registrationComplete: false, status: 'negotiating' })
+      expect(
+        screen.getByText(
+          /Move the sponsor to Closed Won before sending registration/,
+        ),
+      ).toBeInTheDocument()
+      expect(screen.queryByTestId('portal-section')).not.toBeInTheDocument()
+    })
+
     it('shows completion message when registration is done', () => {
       renderView({
         registrationComplete: true,

__tests__/lib/program/time-utils.test.ts

@@ -0,0 +1,90 @@
+import { isScheduleInPast, isScheduleToday } from '@/lib/program/time-utils'
+
+describe('program/time-utils.ts', () => {
+  describe('isScheduleInPast', () => {
+    it('should return true for dates in the past', () => {
+      const currentTime = new Date('2025-10-28T12:00:00')
+      const scheduleDate = '2025-10-27'
+      expect(isScheduleInPast(scheduleDate, currentTime)).toBe(true)
+    })
+
+    it('should return false for today', () => {
+      const currentTime = new Date('2025-10-27T12:00:00')
+      const scheduleDate = '2025-10-27'
+      expect(isScheduleInPast(scheduleDate, currentTime)).toBe(false)
+    })
+
+    it('should return false for dates in the future', () => {
+      const currentTime = new Date('2025-10-27T12:00:00')
+      const scheduleDate = '2025-10-28'
+      expect(isScheduleInPast(scheduleDate, currentTime)).toBe(false)
+    })
+
+    it('should handle dates far in the past', () => {
+      const currentTime = new Date('2025-10-27T12:00:00')
+      const scheduleDate = '2024-01-01'
+      expect(isScheduleInPast(scheduleDate, currentTime)).toBe(true)
+    })
+
+    it('should handle dates far in the future', () => {
+      const currentTime = new Date('2025-10-27T12:00:00')
+      const scheduleDate = '2026-12-31'
+      expect(isScheduleInPast(scheduleDate, currentTime)).toBe(false)
+    })
+
+    it('should ignore time of day (only compare dates)', () => {
+      // Morning
+      const morningTime = new Date('2025-10-28T08:00:00')
+      expect(isScheduleInPast('2025-10-27', morningTime)).toBe(true)
+
+      // Evening
+      const eveningTime = new Date('2025-10-28T23:59:59')
+      expect(isScheduleInPast('2025-10-27', eveningTime)).toBe(true)
+
+      // Today should still be false regardless of time
+      expect(isScheduleInPast('2025-10-28', morningTime)).toBe(false)
+      expect(isScheduleInPast('2025-10-28', eveningTime)).toBe(false)
+    })
+  })
+
+  describe('isScheduleToday', () => {
+    it('should return true when schedule date matches current date', () => {
+      const currentTime = new Date('2025-10-27T12:00:00')
+      const scheduleDate = '2025-10-27'
+      expect(isScheduleToday(scheduleDate, currentTime)).toBe(true)
+    })
+
+    it('should return false when schedule date is in the past', () => {
+      const currentTime = new Date('2025-10-28T12:00:00')
+      const scheduleDate = '2025-10-27'
+      expect(isScheduleToday(scheduleDate, currentTime)).toBe(false)
+    })
+
+    it('should return false when schedule date is in the future', () => {
+      const currentTime = new Date('2025-10-27T12:00:00')
+      const scheduleDate = '2025-10-28'
+      expect(isScheduleToday(scheduleDate, currentTime)).toBe(false)
+    })
+  })
+
+  describe('integration: isScheduleInPast and isScheduleToday', () => {
+    it('should have mutually exclusive results for past and today', () => {
+      const currentTime = new Date('2025-10-27T12:00:00')
+      const yesterdayDate = '2025-10-26'
+      const todayDate = '2025-10-27'
+      const tomorrowDate = '2025-10-28'
+
+      // Yesterday
+      expect(isScheduleInPast(yesterdayDate, currentTime)).toBe(true)
+      expect(isScheduleToday(yesterdayDate, currentTime)).toBe(false)
+
+      // Today
+      expect(isScheduleInPast(todayDate, currentTime)).toBe(false)
+      expect(isScheduleToday(todayDate, currentTime)).toBe(true)
+
+      // Tomorrow
+      expect(isScheduleInPast(tomorrowDate, currentTime)).toBe(false)
+      expect(isScheduleToday(tomorrowDate, currentTime)).toBe(false)
+    })
+  })
+})

__tests__/lib/proposal/schemas.test.ts

@@ -121,21 +121,75 @@ describe('ProposalInputSchema (strict)', () => {
     expect(result.success).toBe(false)
   })
 
-  it('requires capacity for workshop formats', () => {
+  it('accepts workshop format with capacity', () => {
+    const result = ProposalInputSchema.safeParse({
+      ...fullProposal,
+      format: Format.workshop_120,
+      capacity: 30,
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('accepts workshop format without capacity', () => {
+    const result = ProposalInputSchema.safeParse({
+      ...fullProposal,
+      format: Format.workshop_120,
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('accepts workshop format with prerequisites', () => {
     const result = ProposalInputSchema.safeParse({
       ...fullProposal,
       format: Format.workshop_120,
+      capacity: 30,
+      prerequisites: 'Bring a computer with Docker installed',
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('accepts non-workshop format without prerequisites', () => {
+    const result = ProposalInputSchema.safeParse({
+      ...fullProposal,
+      format: Format.presentation_40,
+      prerequisites: undefined,
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects prerequisites for non-workshop formats', () => {
+    const result = ProposalInputSchema.safeParse({
+      ...fullProposal,
+      format: Format.presentation_40,
+      prerequisites: 'Should not be allowed',
     })
     expect(result.success).toBe(false)
   })
 
-  it('accepts workshop format with capacity', () => {
+  it('normalizes empty prerequisites to undefined', () => {
+    const result = ProposalInputSchema.safeParse({
+      ...fullProposal,
+      format: Format.workshop_120,
+      capacity: 30,
+      prerequisites: '   ',
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.prerequisites).toBeUndefined()
+    }
+  })
+
+  it('trims whitespace from prerequisites', () => {
     const result = ProposalInputSchema.safeParse({
       ...fullProposal,
       format: Format.workshop_120,
       capacity: 30,
+      prerequisites: '  Docker required  ',
     })
     expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.prerequisites).toBe('Docker required')
+    }
   })
 
   it('rejects missing title', () => {

__tests__/lib/proposal/state-machine.test.ts

@@ -44,6 +44,11 @@ describe('actionStateMachine', () => {
       expect(result).toEqual({ status: Status.accepted, isValidAction: true })
     })
 
+    it('allows organizer to waitlist', () => {
+      const result = actionStateMachine(Status.submitted, Action.waitlist, true)
+      expect(result).toEqual({ status: Status.waitlisted, isValidAction: true })
+    })
+
     it('allows organizer to reject', () => {
       const result = actionStateMachine(Status.submitted, Action.reject, true)
       expect(result).toEqual({ status: Status.rejected, isValidAction: true })
@@ -54,6 +59,15 @@ describe('actionStateMachine', () => {
       expect(result.isValidAction).toBe(false)
     })
 
+    it('prevents non-organizer from waitlisting', () => {
+      const result = actionStateMachine(
+        Status.submitted,
+        Action.waitlist,
+        false,
+      )
+      expect(result.isValidAction).toBe(false)
+    })
+
     it('prevents non-organizer from rejecting', () => {
       const result = actionStateMachine(Status.submitted, Action.reject, false)
       expect(result.isValidAction).toBe(false)
@@ -110,6 +124,37 @@ describe('actionStateMachine', () => {
     })
   })
 
+  describe('waitlisted status', () => {
+    it('allows organizer to accept', () => {
+      const result = actionStateMachine(Status.waitlisted, Action.accept, true)
+      expect(result).toEqual({ status: Status.accepted, isValidAction: true })
+    })
+
+    it('allows organizer to reject', () => {
+      const result = actionStateMachine(Status.waitlisted, Action.reject, true)
+      expect(result).toEqual({ status: Status.rejected, isValidAction: true })
+    })
+
+    it('allows speaker to withdraw', () => {
+      const result = actionStateMachine(
+        Status.waitlisted,
+        Action.withdraw,
+        false,
+      )
+      expect(result).toEqual({ status: Status.withdrawn, isValidAction: true })
+    })
+
+    it('prevents non-organizer from accepting', () => {
+      const result = actionStateMachine(Status.waitlisted, Action.accept, false)
+      expect(result.isValidAction).toBe(false)
+    })
+
+    it('prevents non-organizer from rejecting', () => {
+      const result = actionStateMachine(Status.waitlisted, Action.reject, false)
+      expect(result.isValidAction).toBe(false)
+    })
+  })
+
   describe('full lifecycle: draft → submitted → accepted → confirmed', () => {
     it('transitions through the complete happy path', () => {
       let { status } = actionStateMachine(Status.draft, Action.submit, false)
@@ -119,5 +164,14 @@ describe('actionStateMachine', () => {
       ;({ status } = actionStateMachine(status, Action.confirm, false))
       expect(status).toBe(Status.confirmed)
     })
+
+    it('transitions through waitlist path: draft → submitted → waitlisted → accepted', () => {
+      let { status } = actionStateMachine(Status.draft, Action.submit, false)
+      expect(status).toBe(Status.submitted)
+      ;({ status } = actionStateMachine(status, Action.waitlist, true))
+      expect(status).toBe(Status.waitlisted)
+      ;({ status } = actionStateMachine(status, Action.accept, true))
+      expect(status).toBe(Status.accepted)
+    })
   })
 })

__tests__/lib/proposal/validation.test.ts

@@ -103,42 +103,6 @@ describe('validateProposalForm', () => {
     expect(errors.tos).toBe(PROPOSAL_VALIDATION_MESSAGES.TOS_REQUIRED)
   })
 
-  it('returns capacity error for workshop_120 without capacity', () => {
-    const errors = validateProposalForm(
-      makeValidProposal({ format: Format.workshop_120 }),
-    )
-    expect(errors.capacity).toBe(PROPOSAL_VALIDATION_MESSAGES.CAPACITY_REQUIRED)
-  })
-
-  it('returns capacity error for workshop_240 without capacity', () => {
-    const errors = validateProposalForm(
-      makeValidProposal({ format: Format.workshop_240 }),
-    )
-    expect(errors.capacity).toBe(PROPOSAL_VALIDATION_MESSAGES.CAPACITY_REQUIRED)
-  })
-
-  it('accepts workshop format with capacity', () => {
-    const errors = validateProposalForm(
-      makeValidProposal({ format: Format.workshop_120, capacity: 30 }),
-    )
-    expect(errors.capacity).toBeUndefined()
-  })
-
-  it('does not return capacity error for non-workshop formats', () => {
-    const errors = validateProposalForm(
-      makeValidProposal({ format: Format.presentation_40 }),
-    )
-    expect(errors.capacity).toBeUndefined()
-  })
-
-  it('suppresses capacity check when requireCapacity is false', () => {
-    const errors = validateProposalForm(
-      makeValidProposal({ format: Format.workshop_120 }),
-      { requireCapacity: false },
-    )
-    expect(errors.capacity).toBeUndefined()
-  })
-
   it('returns multiple errors simultaneously', () => {
     const errors = validateProposalForm(
       makeValidProposal({

__tests__/lib/sanity/client.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from 'vitest'
+import { speakerImageUrl } from '@/lib/sanity/client'
+
+describe('speakerImageUrl', () => {
+  const sanityCdnUrl =
+    'https://cdn.sanity.io/images/testproject/production/abc123-200x200.jpg'
+  const githubAvatarUrl = 'https://avatars.githubusercontent.com/u/12345?v=4'
+  const linkedinAvatarUrl =
+    'https://media.licdn.com/dms/image/v2/abc123/profile-photo.jpg'
+
+  it('should transform Sanity CDN URLs through the image builder', () => {
+    const result = speakerImageUrl(sanityCdnUrl)
+
+    expect(result).toContain('cdn.sanity.io')
+  })
+
+  it('should return GitHub avatar URLs unchanged', () => {
+    expect(speakerImageUrl(githubAvatarUrl)).toBe(githubAvatarUrl)
+  })
+
+  it('should return LinkedIn avatar URLs unchanged', () => {
+    expect(speakerImageUrl(linkedinAvatarUrl)).toBe(linkedinAvatarUrl)
+  })
+
+  it('should not transform non-Sanity URLs even with custom options', () => {
+    const result = speakerImageUrl(githubAvatarUrl, {
+      width: 800,
+      height: 800,
+      fit: 'crop',
+    })
+
+    expect(result).toBe(githubAvatarUrl)
+  })
+
+  it('should not transform plain http URLs', () => {
+    const httpUrl = 'http://example.com/photo.jpg'
+    expect(speakerImageUrl(httpUrl)).toBe(httpUrl)
+  })
+})