MOPC-Portal/tests/unit/lunch-router.test.ts

import { afterAll, describe, expect, it } from 'vitest'
import { prisma, createCaller } from '../setup'
import {
  createTestUser,
  createTestProgram,
  createTestProject,
  cleanupTestData,
  uid,
} from '../helpers'
import { lunchRouter } from '@/server/routers/lunch'

const programIds: string[] = []
const userIds: string[] = []

afterAll(async () => {
  for (const programId of programIds) {
    await prisma.memberLunchPick.deleteMany({
      where: { attendingMember: { confirmation: { project: { programId } } } },
    })
    await prisma.attendingMember.deleteMany({
      where: { confirmation: { project: { programId } } },
    })
    await prisma.finalistConfirmation.deleteMany({ where: { project: { programId } } })
    await prisma.externalAttendee.deleteMany({ where: { lunchEvent: { programId } } })
    await prisma.dish.deleteMany({ where: { lunchEvent: { programId } } })
    await prisma.lunchEvent.deleteMany({ where: { programId } })
    await cleanupTestData(programId, [])
  }
  if (userIds.length > 0) {
    await prisma.auditLog.deleteMany({ where: { userId: { in: userIds } } })
    await prisma.user.deleteMany({ where: { id: { in: userIds } } })
  }
})

async function newAdminCaller() {
  const admin = await createTestUser('SUPER_ADMIN')
  userIds.push(admin.id)
  const caller = createCaller(lunchRouter, {
    id: admin.id,
    email: admin.email,
    role: 'SUPER_ADMIN',
  })
  return { admin, caller }
}

describe('lunch.getEvent', () => {
  it('lazily creates a LunchEvent on first call', async () => {
    const program = await createTestProgram({ name: `lunch-get-${uid()}` })
    programIds.push(program.id)
    const { caller } = await newAdminCaller()
    const result = await caller.getEvent({ programId: program.id })
    expect(result.programId).toBe(program.id)
    expect(result.enabled).toBe(false)
    expect(result.changeCutoffHours).toBe(48)
    const row = await prisma.lunchEvent.findUnique({ where: { programId: program.id } })
    expect(row).not.toBeNull()
  })

  it('returns the same row on subsequent calls', async () => {
    const program = await createTestProgram({ name: `lunch-get-${uid()}` })
    programIds.push(program.id)
    const { caller } = await newAdminCaller()
    const a = await caller.getEvent({ programId: program.id })
    const b = await caller.getEvent({ programId: program.id })
    expect(a.id).toBe(b.id)
  })
})

describe('dish CRUD', () => {
  it('createDish + listDishes returns dishes ordered by sortOrder', async () => {
    const program = await createTestProgram({ name: `dish-list-${uid()}` })
    programIds.push(program.id)
    const { caller } = await newAdminCaller()
    const event = await caller.getEvent({ programId: program.id })
    await caller.createDish({
      lunchEventId: event.id, name: 'Sea bass', dietaryTags: ['PESCATARIAN'], sortOrder: 1,
    })
    await caller.createDish({
      lunchEventId: event.id, name: 'Risotto', dietaryTags: ['VEGETARIAN'], sortOrder: 0,
    })
    const dishes = await caller.listDishes({ lunchEventId: event.id })
    expect(dishes.map((d) => d.name)).toEqual(['Risotto', 'Sea bass'])
  })

  it('updateDish patches name + tags', async () => {
    const program = await createTestProgram({ name: `dish-upd-${uid()}` })
    programIds.push(program.id)
    const { caller } = await newAdminCaller()
    const event = await caller.getEvent({ programId: program.id })
    const dish = await caller.createDish({ lunchEventId: event.id, name: 'A', dietaryTags: [] })
    const updated = await caller.updateDish({
      dishId: dish.id, name: 'B', dietaryTags: ['VEGAN'],
    })
    expect(updated.name).toBe('B')
    expect(updated.dietaryTags).toEqual(['VEGAN'])
  })

  it('deleteDish sets dishId=null on existing picks', async () => {
    const program = await createTestProgram({ name: `dish-del-${uid()}` })
    programIds.push(program.id)
    const { caller } = await newAdminCaller()
    const event = await caller.getEvent({ programId: program.id })
    const dish = await caller.createDish({ lunchEventId: event.id, name: 'X', dietaryTags: [] })
    const user = await createTestUser('APPLICANT')
    userIds.push(user.id)
    const project = await createTestProject(program.id, {
      title: `dish-del-proj-${uid()}`,
      competitionCategory: 'STARTUP',
    })
    const conf = await prisma.finalistConfirmation.create({
      data: {
        projectId: project.id, category: 'STARTUP', status: 'CONFIRMED',
        deadline: new Date(Date.now() + 86_400_000), token: `tok-${uid()}`,
      },
    })
    const member = await prisma.attendingMember.create({
      data: { confirmationId: conf.id, userId: user.id },
    })
    await prisma.memberLunchPick.create({
      data: { attendingMemberId: member.id, dishId: dish.id, pickedAt: new Date() },
    })
    await caller.deleteDish({ dishId: dish.id })
    const pick = await prisma.memberLunchPick.findUnique({
      where: { attendingMemberId: member.id },
    })
    expect(pick?.dishId).toBeNull()
  })

  it('reorderDishes commits new sortOrder values', async () => {
    const program = await createTestProgram({ name: `dish-reorder-${uid()}` })
    programIds.push(program.id)
    const { caller } = await newAdminCaller()
    const event = await caller.getEvent({ programId: program.id })
    const a = await caller.createDish({
      lunchEventId: event.id, name: 'a', dietaryTags: [], sortOrder: 0,
    })
    const b = await caller.createDish({
      lunchEventId: event.id, name: 'b', dietaryTags: [], sortOrder: 1,
    })
    await caller.reorderDishes({
      ordered: [
        { dishId: b.id, sortOrder: 0 },
        { dishId: a.id, sortOrder: 1 },
      ],
    })
    const dishes = await caller.listDishes({ lunchEventId: event.id })
    expect(dishes.map((d) => d.name)).toEqual(['b', 'a'])
  })
})

describe('lunch.updateEvent', () => {
  it('patches an arbitrary subset of fields', async () => {
    const program = await createTestProgram({ name: `lunch-upd-${uid()}` })
    programIds.push(program.id)
    const { caller } = await newAdminCaller()
    await caller.getEvent({ programId: program.id })
    const updated = await caller.updateEvent({
      programId: program.id,
      enabled: true,
      eventAt: new Date('2026-06-28T12:30:00Z'),
      venue: 'Hôtel Hermitage',
      changeCutoffHours: 24,
      extraRecipients: ['caterer@example.com'],
    })
    expect(updated.enabled).toBe(true)
    expect(updated.venue).toBe('Hôtel Hermitage')
    expect(updated.changeCutoffHours).toBe(24)
    expect(updated.extraRecipients).toEqual(['caterer@example.com'])
  })

  it('lazy-creates the event on first updateEvent', async () => {
    const program = await createTestProgram({ name: `lunch-lazy-${uid()}` })
    programIds.push(program.id)
    const { caller } = await newAdminCaller()
    const updated = await caller.updateEvent({
      programId: program.id,
      enabled: true,
    })
    expect(updated.enabled).toBe(true)
    expect(updated.programId).toBe(program.id)
  })

  it('rejects non-admin callers', async () => {
    const program = await createTestProgram({ name: `lunch-rej-${uid()}` })
    programIds.push(program.id)
    const member = await createTestUser('APPLICANT')
    userIds.push(member.id)
    const memberCaller = createCaller(lunchRouter, {
      id: member.id,
      email: member.email,
      role: 'APPLICANT',
    })
    await expect(
      memberCaller.updateEvent({ programId: program.id, enabled: true }),
    ).rejects.toThrow()
  })
})