MOPC-Portal/tests/unit/audience-window.test.ts

/**
 * Grand-finale audience favorite-vote windows:
 * - admin opens a per-category (or overall) window with a duration
 * - votes are gated server-side: phase OPEN, before closesAt, category match
 * - one vote per voter token per window (re-vote updates), max 3 voters per IP
 * - no cron required: the closesAt check at vote/read time is the source of truth
 */
import { describe, it, expect, beforeAll, afterAll } from 'vitest'
import { prisma, createCaller } from '../setup'
import {
  createTestUser,
  createTestProgram,
  createTestCompetition,
  createTestRound,
  createTestProject,
  cleanupTestData,
  uid,
} from '../helpers'
import { liveVotingRouter } from '@/server/routers/live-voting'

let program: any
let round: any
let session: any
let startup1: any
let startup2: any
let concept1: any
let admin: any
let adminCaller: ReturnType<typeof createCaller>
let publicCaller: ReturnType<typeof createCaller>
let tokenA: string
let tokenB: string

async function makeVoter() {
  const res = await publicCaller.registerAudienceVoter({ sessionId: session.id })
  return res.token as string
}

beforeAll(async () => {
  program = await createTestProgram()
  const competition = await createTestCompetition(program.id)
  round = await createTestRound(competition.id, {
    roundType: 'LIVE_FINAL',
    status: 'ROUND_ACTIVE',
  })
  startup1 = await createTestProject(program.id, { competitionCategory: 'STARTUP' })
  startup2 = await createTestProject(program.id, { competitionCategory: 'STARTUP' })
  concept1 = await createTestProject(program.id, { competitionCategory: 'BUSINESS_CONCEPT' })
  await prisma.round.update({
    where: { id: round.id },
    data: { configJson: { projectOrder: [concept1.id, startup1.id, startup2.id] } },
  })
  session = await prisma.liveVotingSession.create({
    data: { roundId: round.id, allowAudienceVotes: true },
  })
  admin = await createTestUser('SUPER_ADMIN')
  adminCaller = createCaller(liveVotingRouter, admin)
  publicCaller = createCaller(liveVotingRouter, admin) // public procedures ignore the session user
  tokenA = await makeVoter()
  tokenB = await makeVoter()
})

afterAll(async () => {
  await cleanupTestData(program.id, [admin.id])
})

describe('window lifecycle', () => {
  it('opens a category window with a closing time', async () => {
    const s = await adminCaller.openAudienceWindow({
      sessionId: session.id,
      windowKey: 'CATEGORY:STARTUP',
      durationMinutes: 5,
    })
    expect(s.audiencePhase).toBe('OPEN')
    expect(s.audienceWindowKey).toBe('CATEGORY:STARTUP')
    const msLeft = new Date(s.audienceWindowClosesAt!).getTime() - Date.now()
    expect(msLeft).toBeGreaterThan(4 * 60_000)
    expect(msLeft).toBeLessThanOrEqual(5 * 60_000)
  })

  it('rejects opening a second window while one is open', async () => {
    await expect(
      adminCaller.openAudienceWindow({
        sessionId: session.id,
        windowKey: 'CATEGORY:BUSINESS_CONCEPT',
        durationMinutes: 5,
      })
    ).rejects.toThrow()
  })
})

describe('casting favorite votes', () => {
  it('accepts a vote for an in-category project and re-vote updates in place', async () => {
    await publicCaller.castFavoriteVote({
      sessionId: session.id,
      token: tokenA,
      projectId: startup1.id,
    })
    await publicCaller.castFavoriteVote({
      sessionId: session.id,
      token: tokenA,
      projectId: startup2.id,
    })
    const rows = await prisma.audienceFavoriteVote.findMany({
      where: { sessionId: session.id, windowKey: 'CATEGORY:STARTUP' },
    })
    expect(rows).toHaveLength(1)
    expect(rows[0].projectId).toBe(startup2.id)
  })

  it('rejects a vote for a project outside the open category', async () => {
    await expect(
      publicCaller.castFavoriteVote({
        sessionId: session.id,
        token: tokenB,
        projectId: concept1.id,
      })
    ).rejects.toThrow(/category/i)
  })

  it('rejects an invalid token', async () => {
    await expect(
      publicCaller.castFavoriteVote({
        sessionId: session.id,
        token: 'bogus',
        projectId: startup1.id,
      })
    ).rejects.toThrow()
  })

  it('rejects votes after closesAt even without an explicit close (no cron)', async () => {
    await prisma.liveVotingSession.update({
      where: { id: session.id },
      data: { audienceWindowClosesAt: new Date(Date.now() - 1000) },
    })
    await expect(
      publicCaller.castFavoriteVote({
        sessionId: session.id,
        token: tokenB,
        projectId: startup1.id,
      })
    ).rejects.toThrow()
    // getAudienceWindow also reports closed
    const win = await publicCaller.getAudienceWindow({ sessionId: session.id })
    expect(win.open).toBe(false)
  })

  it('close + re-open works and votes flow again in the new category', async () => {
    await adminCaller.closeAudienceWindow({ sessionId: session.id })
    await expect(
      publicCaller.castFavoriteVote({
        sessionId: session.id,
        token: tokenB,
        projectId: startup1.id,
      })
    ).rejects.toThrow()

    await adminCaller.openAudienceWindow({
      sessionId: session.id,
      windowKey: 'CATEGORY:BUSINESS_CONCEPT',
      durationMinutes: 5,
    })
    await publicCaller.castFavoriteVote({
      sessionId: session.id,
      token: tokenB,
      projectId: concept1.id,
    })
    const rows = await prisma.audienceFavoriteVote.findMany({
      where: { sessionId: session.id, windowKey: 'CATEGORY:BUSINESS_CONCEPT' },
    })
    expect(rows).toHaveLength(1)
  })
})

describe('overall favorite window', () => {
  it('requires the admin toggle before opening', async () => {
    await adminCaller.closeAudienceWindow({ sessionId: session.id })
    await expect(
      adminCaller.openAudienceWindow({ sessionId: session.id, windowKey: 'OVERALL', durationMinutes: 5 })
    ).rejects.toThrow()

    await adminCaller.updateSessionConfig({ sessionId: session.id, allowOverallFavorite: true })
    const s = await adminCaller.openAudienceWindow({
      sessionId: session.id,
      windowKey: 'OVERALL',
      durationMinutes: 5,
    })
    expect(s.audienceWindowKey).toBe('OVERALL')
  })

  it('accepts any ordered project in OVERALL mode', async () => {
    await publicCaller.castFavoriteVote({
      sessionId: session.id,
      token: tokenA,
      projectId: concept1.id,
    })
    await publicCaller.castFavoriteVote({
      sessionId: session.id,
      token: tokenB,
      projectId: startup1.id,
    })
    const rows = await prisma.audienceFavoriteVote.findMany({
      where: { sessionId: session.id, windowKey: 'OVERALL' },
    })
    expect(rows).toHaveLength(2)
  })
})

describe('IP cap', () => {
  it('rejects a 4th distinct voter from the same IP in one window', async () => {
    // tokenA + tokenB already voted in OVERALL from ctx ip 127.0.0.1, but their
    // stored ipAddress comes from ctx — normalize the rows to be explicit:
    await prisma.audienceFavoriteVote.updateMany({
      where: { sessionId: session.id, windowKey: 'OVERALL' },
      data: { ipAddress: '127.0.0.1' },
    })
    const tokenC = await makeVoter()
    await publicCaller.castFavoriteVote({
      sessionId: session.id,
      token: tokenC,
      projectId: startup2.id,
    })
    const tokenD = await makeVoter()
    await expect(
      publicCaller.castFavoriteVote({
        sessionId: session.id,
        token: tokenD,
        projectId: startup1.id,
      })
    ).rejects.toThrow(/limit/i)
  })

  it('an existing voter on a capped IP can still change their vote', async () => {
    await publicCaller.castFavoriteVote({
      sessionId: session.id,
      token: tokenA,
      projectId: startup2.id,
    })
    const row = await prisma.audienceFavoriteVote.findFirst({
      where: { sessionId: session.id, windowKey: 'OVERALL', audienceVoter: { token: tokenA } },
    })
    expect(row?.projectId).toBe(startup2.id)
  })
})

describe('reads', () => {
  it('getAudienceWindow lists eligible projects in order and the caller’s vote', async () => {
    const win = await publicCaller.getAudienceWindow({ sessionId: session.id, token: tokenA })
    expect(win.open).toBe(true)
    expect(win.windowKey).toBe('OVERALL')
    expect(win.projects.map((p: any) => p.id)).toEqual([concept1.id, startup1.id, startup2.id])
    expect(win.myVoteProjectId).toBe(startup2.id)
  })

  it('getFavoriteTallies aggregates per window per project', async () => {
    const tallies = await adminCaller.getFavoriteTallies({ sessionId: session.id })
    const overall = tallies.windows.find((w: any) => w.windowKey === 'OVERALL')
    expect(overall.totalVotes).toBe(3)
    const startup2Count = overall.projects.find((p: any) => p.projectId === startup2.id)?.count
    expect(startup2Count).toBe(2)
  })

  it('getAudienceContextByRound resolves the session publicly', async () => {
    const ctx = await publicCaller.getAudienceContextByRound({ roundId: round.id })
    expect(ctx?.sessionId).toBe(session.id)
    expect(ctx?.allowAudienceVotes).toBe(true)
  })

  it('non-admins cannot open windows or read tallies', async () => {
    const juror = await createTestUser('JURY_MEMBER')
    const jurorCaller = createCaller(liveVotingRouter, juror)
    await expect(
      jurorCaller.openAudienceWindow({ sessionId: session.id, windowKey: 'OVERALL', durationMinutes: 5 })
    ).rejects.toThrow()
    await expect(jurorCaller.getFavoriteTallies({ sessionId: session.id })).rejects.toThrow()
    await prisma.user.delete({ where: { id: juror.id } })
  })
})