Janady13/missionmatch / internal/integration/collision_integration_test.go

1//go:build integration 2 3// Cross opportunity collision deconfliction integration. Proves at runtime against a REAL Postgres what the 4// unit tests cannot: the alerts watch loop's fourth trigger detects a scarce cleared candidate proposed or 5// approved on the slates of two or more DISTINCT competing OPEN opportunities, surfaces ONE advisory alert per 6// collided candidate (urgent when scarce cleared or double committed) naming the competing bids and the 7// deterministic best fit suggested primary, is idempotent across sweeps, and is RLS isolated per org. It never 8// auto rejects a slate member. Migration 0040 (the collision alert_type) must be applied. 9// 10// Run: go test -tags=integration ./internal/integration/ -run Collision -v 11// Env: MM_APP_DSN, MM_MIGRATOR_DSN. 12package integration 13 14import ( 15 "context" 16 "strings" 17 "testing" 18 19 "github.com/google/uuid" 20 21 "github.com/missionworkforce/missionmatch/internal/modules/alerts" 22) 23 24// seedOpenOpportunityWithMember seeds one OPEN opportunity, a requirement under it, a slate for that 25// requirement, and the given candidate as an approved slate member with the given total score, via the migrator. 26// It returns the opportunity name so the test can assert the collision detail and suggested primary. 27func seedOpenOpportunityWithMember(t *testing.T, org, cand uuid.UUID, name string, total int) { 28 t.Helper() 29 ctx := context.Background() 30 oppID := uuid.New() 31 if _, err := migrator.Exec(ctx, 32 `INSERT INTO opportunities (id, organization_id, name, status, due_date) VALUES ($1,$2,$3,'open', now() + interval '30 days')`, 33 oppID, org, name); err != nil { 34 t.Fatalf("seed opportunity: %v", err) 35 } 36 reqID := uuid.New() 37 if _, err := migrator.Exec(ctx, 38 `INSERT INTO requirements (id, organization_id, opportunity_id, title, required_level, required_poly) VALUES ($1,$2,$3,$4,'secret','none')`, 39 reqID, org, oppID, "Req for "+name); err != nil { 40 t.Fatalf("seed requirement: %v", err) 41 } 42 slateID := uuid.New() 43 if _, err := migrator.Exec(ctx, 44 `INSERT INTO slates (id, organization_id, requirement_id, name) VALUES ($1,$2,$3,$4)`, 45 slateID, org, reqID, "Slate for "+name); err != nil { 46 t.Fatalf("seed slate: %v", err) 47 } 48 band := "yellow" 49 if total >= 90 { 50 band = "green" 51 } 52 if _, err := migrator.Exec(ctx, 53 `INSERT INTO slate_members 54 (organization_id, slate_id, candidate_id, total_score, band, 55 clearance_score, skills_score, certs_score, customer_score, experience_score, location_score, 56 explanation, trace, decision, decided_at) 57 VALUES ($1,$2,$3,$4,$5,100,80,80,80,80,80,'seed','[]','approved', now())`, 58 org, slateID, cand, total, band); err != nil { 59 t.Fatalf("seed slate member: %v", err) 60 } 61} 62 63func TestCollisionDeconflictionSweepFlagsScarceDoubleCommitment(t *testing.T) { 64 org := seedOrg(t) 65 // A scarce cleared person: TS/SCI active. They are approved on TWO distinct open bids, Alpha (best fit) and 66 // Beta, so this is both a scarce cleared collision and a true double commitment: urgent. 67 cand := seedCandidate(t, org, "ts_sci", "active", true) 68 seedOpenOpportunityWithMember(t, org, cand.ID, "Program Alpha", 92) // higher score => the best fit primary 69 seedOpenOpportunityWithMember(t, org, cand.ID, "Program Beta", 74) 70 71 svc := alerts.NewService(appDB, nil) 72 sum, err := svc.SweepOrg(ctxOrg(org)) 73 if err != nil { 74 t.Fatalf("sweep: %v", err) 75 } 76 if sum.Collision < 1 { 77 t.Fatalf("the sweep must detect at least one collision, got %d", sum.Collision) 78 } 79 80 // Find the collision alert for this candidate. 81 list, err := svc.ListAlerts(ctxOrg(org), "") 82 if err != nil { 83 t.Fatalf("list alerts: %v", err) 84 } 85 var found *alerts.Alert 86 for i := range list { 87 if list[i].AlertType == alerts.TypeCollision && list[i].SubjectID == cand.ID.String() { 88 found = &list[i] 89 break 90 } 91 } 92 if found == nil { 93 t.Fatalf("a collision alert for the double committed candidate must exist, got %+v", list) 94 } 95 if found.Severity != alerts.SeverityUrgent { 96 t.Errorf("a scarce cleared double commitment must be urgent, got %q", found.Severity) 97 } 98 if found.SubjectType != alerts.SubjectCandidate { 99 t.Errorf("the collision subject must be the candidate, got %q", found.SubjectType) 100 } 101 if !strings.Contains(found.Title, "Scarce cleared") || !strings.Contains(found.Title, "2 competing") { 102 t.Errorf("the title must name a scarce cleared person on 2 competing bids, got %q", found.Title) 103 } 104 // The detail names both bids, the deterministic best fit suggested primary (Alpha, the higher score), and 105 // the clearance disclosure. It never auto rejects. 106 for _, want := range []string{"Program Alpha", "Program Beta", "Suggested primary (best fit): Program Alpha", "not verified"} { 107 if !strings.Contains(found.Detail, want) { 108 t.Errorf("the collision detail must contain %q, got %q", want, found.Detail) 109 } 110 } 111 112 // Idempotent: a second sweep upserts the same one row, no duplicate collision alert for this candidate. 113 if _, err := svc.SweepOrg(ctxOrg(org)); err != nil { 114 t.Fatalf("second sweep: %v", err) 115 } 116 list2, err := svc.ListAlerts(ctxOrg(org), "") 117 if err != nil { 118 t.Fatalf("list after second sweep: %v", err) 119 } 120 count := 0 121 for _, a := range list2 { 122 if a.AlertType == alerts.TypeCollision && a.SubjectID == cand.ID.String() { 123 count++ 124 } 125 } 126 if count != 1 { 127 t.Fatalf("the dedupe upsert must keep exactly one collision alert per candidate, got %d", count) 128 } 129} 130 131func TestCollisionDeconflictionRLSIsolation(t *testing.T) { 132 // Two orgs, each with its OWN scarce cleared candidate double committed across two of its OWN open bids. 133 // Each org's sweep must surface only its own collision; neither org's candidate may leak into the other's 134 // alert list (the RLS boundary the collision join must never cross). 135 orgA, orgB := seedOrg(t), seedOrg(t) 136 candA := seedCandidate(t, orgA, "ts_sci", "active", true) 137 candB := seedCandidate(t, orgB, "ts_sci", "active", true) 138 seedOpenOpportunityWithMember(t, orgA, candA.ID, "A One", 90) 139 seedOpenOpportunityWithMember(t, orgA, candA.ID, "A Two", 70) 140 seedOpenOpportunityWithMember(t, orgB, candB.ID, "B One", 90) 141 seedOpenOpportunityWithMember(t, orgB, candB.ID, "B Two", 70) 142 143 svc := alerts.NewService(appDB, nil) 144 if _, err := svc.SweepOrg(ctxOrg(orgA)); err != nil { 145 t.Fatalf("sweep org A: %v", err) 146 } 147 if _, err := svc.SweepOrg(ctxOrg(orgB)); err != nil { 148 t.Fatalf("sweep org B: %v", err) 149 } 150 151 // Org A sees its own candidate's collision, and never org B's candidate. 152 listA, err := svc.ListAlerts(ctxOrg(orgA), "") 153 if err != nil { 154 t.Fatalf("list org A: %v", err) 155 } 156 sawOwnA, sawForeignA := false, false 157 for _, a := range listA { 158 if a.AlertType != alerts.TypeCollision { 159 continue 160 } 161 if a.SubjectID == candA.ID.String() { 162 sawOwnA = true 163 } 164 if a.SubjectID == candB.ID.String() || strings.Contains(a.Detail, "B One") || strings.Contains(a.Detail, "B Two") { 165 sawForeignA = true 166 } 167 } 168 if !sawOwnA { 169 t.Error("org A must see its own candidate's collision") 170 } 171 if sawForeignA { 172 t.Error("ISOLATION BREACH: org A saw org B's collision candidate or bids") 173 } 174 175 // Org B symmetrically sees only its own. 176 listB, err := svc.ListAlerts(ctxOrg(orgB), "") 177 if err != nil { 178 t.Fatalf("list org B: %v", err) 179 } 180 for _, a := range listB { 181 if a.AlertType == alerts.TypeCollision && (a.SubjectID == candA.ID.String() || strings.Contains(a.Detail, "A One") || strings.Contains(a.Detail, "A Two")) { 182 t.Error("ISOLATION BREACH: org B saw org A's collision candidate or bids") 183 } 184 } 185} 186 187func TestCollisionDeconflictionIgnoresSingleOpportunity(t *testing.T) { 188 // A candidate on only ONE open opportunity is not a collision. 189 org := seedOrg(t) 190 cand := seedCandidate(t, org, "ts_sci", "active", true) 191 seedOpenOpportunityWithMember(t, org, cand.ID, "Solo Program", 88) 192 193 svc := alerts.NewService(appDB, nil) 194 if _, err := svc.SweepOrg(ctxOrg(org)); err != nil { 195 t.Fatalf("sweep: %v", err) 196 } 197 list, err := svc.ListAlerts(ctxOrg(org), "") 198 if err != nil { 199 t.Fatalf("list alerts: %v", err) 200 } 201 for _, a := range list { 202 if a.AlertType == alerts.TypeCollision && a.SubjectID == cand.ID.String() { 203 t.Fatalf("a candidate on a single opportunity must not be a collision, got %+v", a) 204 } 205 } 206} 207