MOPC/MOPC-Portal
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Simplify routing to award assignment, seed all CSV entries, fix category mapping
All checks were successful
Build and Push Docker Image / build (push) Successful in 8m3s
Details

Browse Source 
- Remove RoutingRule model and routing engine (replaced by direct award assignment)
- Simplify RoutingMode enum: PARALLEL/POST_MAIN → SHARED, keep EXCLUSIVE
- Remove routing router, routing-rules-editor, and related tests
- Update pipeline, award, and notification code to remove routing references
- Seed: include all CSV entries (no filtering/dedup), AI screening handles duplicates
- Seed: fix non-breaking space (U+00A0) bug in category/issue mapping
- Stage filtering: add duplicate detection that flags projects for admin review

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
Matt
2026-02-15 14:25:05 +01:00
parent 382570cebd
commit 9ab4717f96
23 changed files with 249 additions and 2449 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
tests/helpers.ts
View File

@@ -257,35 +257,6 @@ export async function createTestEvaluationForm(
})
}
// ─── Routing Rule Factory ──────────────────────────────────────────────────
export async function createTestRoutingRule(
pipelineId: string,
destinationTrackId: string,
overrides: Partial<{
name: string
priority: number
predicateJson: Record<string, unknown>
sourceTrackId: string
destinationStageId: string
isActive: boolean
}> = {},
) {
const id = uid('rule')
return prisma.routingRule.create({
data: {
id,
pipelineId,
name: overrides.name ?? `Rule ${id}`,
destinationTrackId,
sourceTrackId: overrides.sourceTrackId ?? null,
destinationStageId: overrides.destinationStageId ?? null,
predicateJson: (overrides.predicateJson ?? { field: 'project.status', operator: 'eq', value: 'SUBMITTED' }) as any,
priority: overrides.priority ?? 0,
isActive: overrides.isActive ?? true,
},
})
}
// ─── Filtering Rule Factory ────────────────────────────────────────────────
@@ -397,7 +368,6 @@ export async function cleanupTestData(programId: string, userIds: string[] = [])
await prisma.evaluationDiscussion.deleteMany({ where: { stage: { track: { pipeline: { programId } } } } })
await prisma.projectStageState.deleteMany({ where: { track: { pipeline: { programId } } } })
await prisma.stageTransition.deleteMany({ where: { fromStage: { track: { pipeline: { programId } } } } })
await prisma.routingRule.deleteMany({ where: { pipeline: { programId } } })
await prisma.awardEligibility.deleteMany({ where: { award: { program: { id: programId } } } })
await prisma.awardVote.deleteMany({ where: { award: { program: { id: programId } } } })
await prisma.awardJuror.deleteMany({ where: { award: { program: { id: programId } } } })

99
tests/integration/award-exclusive.test.ts
View File

@@ -1,99 +0,0 @@
/**
* 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')
})
})

117
tests/integration/transition-routing.test.ts
View File

@@ -1,117 +0,0 @@
/**
* I-003: Transition + Routing — Filter Pass → Main + Award Parallel
*/
import { describe, it, expect, beforeAll, afterAll } from 'vitest'
import { prisma } from '../setup'
import {
createTestUser,
createTestProgram,
createTestPipeline,
createTestTrack,
createTestStage,
createTestTransition,
createTestProject,
createTestPSS,
createTestRoutingRule,
cleanupTestData,
} from '../helpers'
import { executeTransition } from '@/server/services/stage-engine'
import { evaluateRoutingRules, executeRouting } from '@/server/services/routing-engine'
let programId: string
let userIds: string[] = []
beforeAll(async () => {
const program = await createTestProgram({ name: 'Transition+Routing Test' })
programId = program.id
})
afterAll(async () => {
await cleanupTestData(programId, userIds)
})
describe('I-003: Transition + Routing — Parallel Award Track', () => {
it('transitions a project then routes it to a parallel award track', async () => {
const admin = await createTestUser('SUPER_ADMIN')
userIds.push(admin.id)
const pipeline = await createTestPipeline(programId)
// Main track: FILTER → EVALUATION
const mainTrack = await createTestTrack(pipeline.id, {
name: 'Main',
kind: 'MAIN',
sortOrder: 0,
})
const filterStage = await createTestStage(mainTrack.id, {
name: 'Filter',
stageType: 'FILTER',
status: 'STAGE_ACTIVE',
sortOrder: 0,
})
const evalStage = await createTestStage(mainTrack.id, {
name: 'Evaluation',
stageType: 'EVALUATION',
status: 'STAGE_ACTIVE',
sortOrder: 1,
})
await createTestTransition(filterStage.id, evalStage.id)
// Award track (PARALLEL)
const awardTrack = await createTestTrack(pipeline.id, {
name: 'Innovation Award',
kind: 'AWARD',
sortOrder: 1,
routingMode: 'PARALLEL',
})
const awardEvalStage = await createTestStage(awardTrack.id, {
name: 'Award Eval',
stageType: 'EVALUATION',
status: 'STAGE_ACTIVE',
sortOrder: 0,
})
// Routing rule: projects from France → Award track (parallel)
await createTestRoutingRule(pipeline.id, awardTrack.id, {
name: 'France → Innovation Award',
priority: 0,
predicateJson: { field: 'project.country', operator: 'eq', value: 'France' },
})
// Create project in filter stage
const project = await createTestProject(programId, { country: 'France' })
await createTestPSS(project.id, mainTrack.id, filterStage.id, { state: 'PENDING' })
// Step 1: Transition from filter → evaluation
const transResult = await executeTransition(
project.id, mainTrack.id, filterStage.id, evalStage.id,
'PENDING', admin.id, prisma
)
expect(transResult.success).toBe(true)
// Step 2: Evaluate routing rules
const matchedRule = await evaluateRoutingRules(
project.id, evalStage.id, pipeline.id, prisma
)
expect(matchedRule).not.toBeNull()
expect(matchedRule!.destinationTrackId).toBe(awardTrack.id)
expect(matchedRule!.routingMode).toBe('PARALLEL')
// Step 3: Execute routing
const routeResult = await executeRouting(project.id, matchedRule!, admin.id, prisma)
expect(routeResult.success).toBe(true)
// Verify: Project should be in BOTH main eval stage AND award eval stage
const mainPSS = await prisma.projectStageState.findFirst({
where: { projectId: project.id, stageId: evalStage.id, exitedAt: null },
})
expect(mainPSS).not.toBeNull() // Still in main track
const awardPSS = await prisma.projectStageState.findFirst({
where: { projectId: project.id, stageId: awardEvalStage.id, exitedAt: null },
})
expect(awardPSS).not.toBeNull() // Also in award track
expect(awardPSS!.state).toBe('PENDING')
})
})

128
tests/unit/routing-engine.test.ts
View File

@@ -1,128 +0,0 @@
/**
* 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()
})
})