MOPC-App/tests/integration/award-exclusive.test.ts

/**
 * I-004: Award Exclusive Routing — Exclusive Route Removes from Main
 */

import { describe, it, expect, beforeAll, afterAll } from 'vitest'
import { prisma } from '../setup'
import {
  createTestUser,
  createTestProgram,
  createTestPipeline,
  createTestTrack,
  createTestStage,
  createTestProject,
  createTestPSS,
  createTestRoutingRule,
  cleanupTestData,
} from '../helpers'
import { evaluateRoutingRules, executeRouting } from '@/server/services/routing-engine'

let programId: string
let userIds: string[] = []

beforeAll(async () => {
  const program = await createTestProgram({ name: 'Award Exclusive Test' })
  programId = program.id
})

afterAll(async () => {
  await cleanupTestData(programId, userIds)
})

describe('I-004: Award Exclusive Routing', () => {
  it('exclusive routing exits all active PSS and creates new PSS in destination', async () => {
    const admin = await createTestUser('SUPER_ADMIN')
    userIds.push(admin.id)

    const pipeline = await createTestPipeline(programId)

    const mainTrack = await createTestTrack(pipeline.id, {
      name: 'Main Track',
      kind: 'MAIN',
      sortOrder: 0,
    })
    const mainStage = await createTestStage(mainTrack.id, {
      name: 'Main Eval',
      stageType: 'EVALUATION',
      status: 'STAGE_ACTIVE',
    })

    // Exclusive award track
    const exclusiveTrack = await createTestTrack(pipeline.id, {
      name: 'Exclusive Award',
      kind: 'AWARD',
      sortOrder: 1,
      routingMode: 'EXCLUSIVE',
    })
    const exclusiveStage = await createTestStage(exclusiveTrack.id, {
      name: 'Exclusive Eval',
      stageType: 'EVALUATION',
      status: 'STAGE_ACTIVE',
    })

    // Routing rule with always-matching predicate
    await createTestRoutingRule(pipeline.id, exclusiveTrack.id, {
      name: 'Exclusive Route',
      priority: 0,
      predicateJson: { field: 'project.country', operator: 'eq', value: 'Monaco' },
    })

    // Create project with active PSS in main track
    const project = await createTestProject(programId, { country: 'Monaco' })
    await createTestPSS(project.id, mainTrack.id, mainStage.id, { state: 'IN_PROGRESS' })

    // Evaluate routing
    const matchedRule = await evaluateRoutingRules(
      project.id, mainStage.id, pipeline.id, prisma
    )
    expect(matchedRule).not.toBeNull()
    expect(matchedRule!.routingMode).toBe('EXCLUSIVE')

    // Execute exclusive routing
    const routeResult = await executeRouting(project.id, matchedRule!, admin.id, prisma)
    expect(routeResult.success).toBe(true)

    // Verify: Main track PSS should be exited with state ROUTED
    const mainPSS = await prisma.projectStageState.findFirst({
      where: { projectId: project.id, trackId: mainTrack.id },
    })
    expect(mainPSS!.exitedAt).not.toBeNull()
    expect(mainPSS!.state).toBe('ROUTED')

    // Verify: Exclusive track PSS should be active
    const exclusivePSS = await prisma.projectStageState.findFirst({
      where: { projectId: project.id, trackId: exclusiveTrack.id, exitedAt: null },
    })
    expect(exclusivePSS).not.toBeNull()
    expect(exclusivePSS!.state).toBe('PENDING')
  })
})