MOPC-Portal/tests/unit/routing-engine.test.ts

/**
 * U-003: Routing — Multiple Rule Match (highest priority wins)
 */

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 } from '@/server/services/routing-engine'

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

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

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

describe('U-003: Multiple Rule Match — Highest Priority Wins', () => {
  it('returns the lowest-priority-number rule when multiple rules match', async () => {
    const pipeline = await createTestPipeline(programId)
    const mainTrack = await createTestTrack(pipeline.id, {
      name: 'Main',
      kind: 'MAIN',
      sortOrder: 0,
    })
    const awardTrackA = await createTestTrack(pipeline.id, {
      name: 'Award A',
      kind: 'AWARD',
      sortOrder: 1,
      routingMode: 'PARALLEL',
    })
    const awardTrackB = await createTestTrack(pipeline.id, {
      name: 'Award B',
      kind: 'AWARD',
      sortOrder: 2,
      routingMode: 'PARALLEL',
    })
    const awardTrackC = await createTestTrack(pipeline.id, {
      name: 'Award C',
      kind: 'AWARD',
      sortOrder: 3,
      routingMode: 'PARALLEL',
    })

    const stage = await createTestStage(mainTrack.id, {
      name: 'Eval',
      stageType: 'EVALUATION',
      status: 'STAGE_ACTIVE',
    })

    // Create destination stages
    await createTestStage(awardTrackA.id, { name: 'A-Eval', sortOrder: 0 })
    await createTestStage(awardTrackB.id, { name: 'B-Eval', sortOrder: 0 })
    await createTestStage(awardTrackC.id, { name: 'C-Eval', sortOrder: 0 })

    // Project from France — all 3 rules match since country=France
    const project = await createTestProject(programId, { country: 'France' })
    await createTestPSS(project.id, mainTrack.id, stage.id, { state: 'PENDING' })

    // Rule 1: priority 10 (lowest = wins)
    await createTestRoutingRule(pipeline.id, awardTrackA.id, {
      name: 'Award A Rule',
      priority: 10,
      predicateJson: { field: 'project.country', operator: 'eq', value: 'France' },
    })

    // Rule 2: priority 20
    await createTestRoutingRule(pipeline.id, awardTrackB.id, {
      name: 'Award B Rule',
      priority: 20,
      predicateJson: { field: 'project.country', operator: 'eq', value: 'France' },
    })

    // Rule 3: priority 30
    await createTestRoutingRule(pipeline.id, awardTrackC.id, {
      name: 'Award C Rule',
      priority: 30,
      predicateJson: { field: 'project.country', operator: 'eq', value: 'France' },
    })

    const matched = await evaluateRoutingRules(project.id, stage.id, pipeline.id, prisma)

    expect(matched).not.toBeNull()
    expect(matched!.destinationTrackId).toBe(awardTrackA.id)
    expect(matched!.priority).toBe(10)
    expect(matched!.ruleName).toBe('Award A Rule')
  })

  it('returns null when no rules match', async () => {
    const pipeline = await createTestPipeline(programId)
    const mainTrack = await createTestTrack(pipeline.id, { kind: 'MAIN', sortOrder: 0 })
    const awardTrack = await createTestTrack(pipeline.id, { kind: 'AWARD', sortOrder: 1 })

    const stage = await createTestStage(mainTrack.id, {
      name: 'Eval',
      status: 'STAGE_ACTIVE',
    })

    await createTestStage(awardTrack.id, { name: 'A-Eval', sortOrder: 0 })

    // Project from Germany, but rule matches only France
    const project = await createTestProject(programId, { country: 'Germany' })
    await createTestPSS(project.id, mainTrack.id, stage.id, { state: 'PENDING' })

    await createTestRoutingRule(pipeline.id, awardTrack.id, {
      name: 'France Only Rule',
      priority: 0,
      predicateJson: { field: 'project.country', operator: 'eq', value: 'France' },
    })

    const matched = await evaluateRoutingRules(project.id, stage.id, pipeline.id, prisma)
    expect(matched).toBeNull()
  })
})