Janady13/missionmatch / internal/integration/alerts_integration_test.go

1//go:build integration 2 3// The proactive alert engine integration. Proves at runtime against a REAL Postgres what the unit tests 4// cannot: the three watch loop triggers fire on real data and produce exactly one typed alert each with the 5// right subject and severity; a second sweep is idempotent (the unique dedupe upsert holds, the counts are 6// unchanged and no duplicate row appears); the RLS boundary holds (a second org sees none of org A's alerts); 7// and SetAlertStatus flips an alert from unread to dismissed. It seeds an org with a candidate whose clearance 8// expires inside the urgent window, a recently posted opportunity_record in an agency the org has a 9// requirement for with a pop_end inside the forward recompete window, and an open requirement that a seeded 10// bench candidate structurally covers. 11// 12// Run: go test -tags=integration ./internal/integration/ -run Alert -v 13// Env: MM_APP_DSN, MM_MIGRATOR_DSN (required). 14package integration 15 16import ( 17 "context" 18 "testing" 19 "time" 20 21 "github.com/google/uuid" 22 "github.com/jackc/pgx/v5" 23 "github.com/jackc/pgx/v5/pgtype" 24 25 "github.com/missionworkforce/missionmatch/internal/modules/alerts" 26 "github.com/missionworkforce/missionmatch/internal/platform/database/dbgen" 27) 28 29// seedExpiringCandidate seeds an available candidate whose clearance expires in the given number of days from 30// today, via the BYPASSRLS migrator. It returns the candidate id so the test can assert the alert's subject. 31func seedExpiringCandidate(t *testing.T, org uuid.UUID, name string, daysOut int) uuid.UUID { 32 t.Helper() 33 cand := seedCandidate(t, org, "secret", "active", true) 34 expires := time.Now().UTC().AddDate(0, 0, daysOut).Format("2006-01-02") 35 if _, err := migrator.Exec(context.Background(), 36 "UPDATE candidates SET full_name=$2, clearance_expires_at=$3 WHERE id=$1", cand.ID, name, expires); err != nil { 37 t.Fatalf("set candidate expiry: %v", err) 38 } 39 return cand.ID 40} 41 42// seedMarketOpportunity seeds one opportunity_record (global public reference data) posted recently with a 43// period of performance ending inside the forward recompete window, in the given agency. It returns the 44// generated opportunity_records id so the test can assert the alert's subject. 45func seedMarketOpportunity(t *testing.T, agency, naics string, postedDaysAgo, popEndMonthsOut int) uuid.UUID { 46 t.Helper() 47 run := uuid.NewString()[:8] 48 srcID := "ALERT-OPP-" + run 49 posted := time.Now().UTC().AddDate(0, 0, -postedDaysAgo) 50 popEnd := time.Now().UTC().AddDate(0, popEndMonthsOut, 0) 51 if err := dbgen.New(migrator).UpsertOpportunityRecord(context.Background(), dbgen.UpsertOpportunityRecordParams{ 52 SourceName: "SAM.gov", SourceRecordID: srcID, RecordKind: "active_solicitation", 53 Title: "Engineering services recompete", Agency: agency, Naics: naics, 54 PostedDate: pgtype.Date{Time: posted, Valid: true}, 55 PopEndDate: pgtype.Date{Time: popEnd, Valid: true}, 56 FetchedAt: time.Now().UTC(), 57 }); err != nil { 58 t.Fatalf("seed market opportunity: %v", err) 59 } 60 var id uuid.UUID 61 if err := migrator.QueryRow(context.Background(), 62 "SELECT id FROM opportunity_records WHERE source_name='SAM.gov' AND source_record_id=$1", srcID).Scan(&id); err != nil { 63 t.Fatalf("resolve opportunity id: %v", err) 64 } 65 return id 66} 67 68// alertByType returns the single alert of the given type from a list, failing if there is not exactly one. 69func alertByType(t *testing.T, list []alerts.Alert, alertType string) alerts.Alert { 70 t.Helper() 71 var found []alerts.Alert 72 for _, a := range list { 73 if a.AlertType == alertType { 74 found = append(found, a) 75 } 76 } 77 if len(found) != 1 { 78 t.Fatalf("expected exactly one %s alert, got %d", alertType, len(found)) 79 } 80 return found[0] 81} 82 83// TestAlertSweepThreeTriggersIdempotentAndIsolated is the end to end proof of the watch loop. It seeds the 84// three actionable events for org A, runs SweepOrg, asserts exactly one alert of each type with the right 85// subject and severity, runs SweepOrg AGAIN and asserts no duplicate (the dedupe upsert holds, counts 86// unchanged), proves a second org sees none of org A's alerts, and flips an alert from unread to dismissed. 87func TestAlertSweepThreeTriggersIdempotentAndIsolated(t *testing.T) { 88 ctx := context.Background() 89 orgA, orgB := seedOrg(t), seedOrg(t) 90 agency := "DEPT OF THE AIR FORCE " + uuid.NewString()[:8] // unique per run so the segment is isolated 91 92 // (i) a candidate whose clearance expires in 20 days (inside the 30 day urgent window). 93 candID := seedExpiringCandidate(t, orgA, "Jane Cleared", 20) 94 95 // (ii) a recently posted opportunity in an agency org A has a requirement for, pop end inside the window. 96 // The requirement gives org A its interest in the agency; the opportunity is the market event. 97 var interestReqID uuid.UUID 98 if err := migrator.QueryRow(ctx, 99 `INSERT INTO requirements (organization_id, title, customer_agency, required_level, required_poly) 100 VALUES ($1,'Existing AF requirement',$2,'none','none') RETURNING id`, orgA, agency).Scan(&interestReqID); err != nil { 101 t.Fatalf("seed interest requirement: %v", err) 102 } 103 // Give the interest requirement a required skill no bench candidate holds, so it is open but NOT 104 // structurally fillable. It exists only to establish org A's interest in the agency for the recompete 105 // trigger and must not also trip the gap_fillable trigger (which would otherwise fire on any open 106 // requirement with no real bar). 107 interestSkill := seedSkillByName(t, "AF Specialty "+uuid.NewString()[:8]) 108 seedRequiredSkill(t, orgA, interestReqID, interestSkill, true) 109 oppID := seedMarketOpportunity(t, agency, "541512", 5, 6) 110 111 // (iii) an open requirement with one required skill that a seeded bench candidate structurally covers. 112 gapReq := seedRequirementWithLevel(t, orgA, "secret") 113 skill := seedSkillByName(t, "Reverse Engineering "+uuid.NewString()[:8]) 114 seedRequiredSkill(t, orgA, gapReq, skill, true) 115 benchCand := seedCandidate(t, orgA, "top_secret", "active", true) // ts_sci over secret clears the ladder 116 seedCandidateSkill(t, orgA, benchCand.ID, skill) // holds the one required skill (full coverage) 117 118 svc := alerts.NewService(appDB, nil) 119 120 sum, err := svc.SweepOrg(ctxOrg(orgA)) 121 if err != nil { 122 t.Fatalf("sweep org A: %v", err) 123 } 124 if sum.ClearanceExpiring != 1 || sum.RecompeteWinnable != 1 || sum.GapFillable != 1 { 125 t.Fatalf("first sweep counts = clearance %d, recompete %d, gap %d; want 1,1,1", 126 sum.ClearanceExpiring, sum.RecompeteWinnable, sum.GapFillable) 127 } 128 129 list, err := svc.ListAlerts(ctxOrg(orgA), "") 130 if err != nil { 131 t.Fatalf("list org A alerts: %v", err) 132 } 133 if len(list) != 3 { 134 t.Fatalf("expected exactly 3 alerts after the first sweep, got %d", len(list)) 135 } 136 137 // (a) clearance_expiring: subject is the candidate, severity urgent (20 days is inside the 30 day window). 138 ca := alertByType(t, list, alerts.TypeClearanceExpiring) 139 if ca.SubjectType != alerts.SubjectCandidate || ca.SubjectID != candID.String() { 140 t.Fatalf("clearance alert subject = %s/%s, want candidate/%s", ca.SubjectType, ca.SubjectID, candID) 141 } 142 if ca.Severity != alerts.SeverityUrgent { 143 t.Fatalf("clearance alert severity = %s, want urgent (20 days out)", ca.Severity) 144 } 145 146 // (b) recompete_winnable: subject is the opportunity record, the market event arm. 147 ra := alertByType(t, list, alerts.TypeRecompeteWinnable) 148 if ra.SubjectType != alerts.SubjectOpportunity || ra.SubjectID != oppID.String() { 149 t.Fatalf("recompete alert subject = %s/%s, want opportunity/%s", ra.SubjectType, ra.SubjectID, oppID) 150 } 151 if ra.Severity != alerts.SeverityWatch { 152 t.Fatalf("recompete alert severity = %s, want watch", ra.Severity) 153 } 154 155 // (c) gap_fillable: subject is the open requirement the bench now structurally covers. 156 ga := alertByType(t, list, alerts.TypeGapFillable) 157 if ga.SubjectType != alerts.SubjectRequirement || ga.SubjectID != gapReq.String() { 158 t.Fatalf("gap alert subject = %s/%s, want requirement/%s", ga.SubjectType, ga.SubjectID, gapReq) 159 } 160 161 // Re sweep: the unique dedupe upsert holds, the counts are unchanged and no duplicate row appears. 162 sum2, err := svc.SweepOrg(ctxOrg(orgA)) 163 if err != nil { 164 t.Fatalf("second sweep org A: %v", err) 165 } 166 if sum2.ClearanceExpiring != 1 || sum2.RecompeteWinnable != 1 || sum2.GapFillable != 1 { 167 t.Fatalf("second sweep counts changed: clearance %d, recompete %d, gap %d; want 1,1,1", 168 sum2.ClearanceExpiring, sum2.RecompeteWinnable, sum2.GapFillable) 169 } 170 list2, err := svc.ListAlerts(ctxOrg(orgA), "") 171 if err != nil { 172 t.Fatalf("list org A alerts after re sweep: %v", err) 173 } 174 if len(list2) != 3 { 175 t.Fatalf("re sweep created a duplicate: expected 3 alerts, got %d", len(list2)) 176 } 177 178 // RLS isolation: org B sees none of org A's alerts. Org B has no seeded events, so its sweep finds nothing. 179 sumB, err := svc.SweepOrg(ctxOrg(orgB)) 180 if err != nil { 181 t.Fatalf("sweep org B: %v", err) 182 } 183 if sumB.Total() != 0 { 184 t.Fatalf("org B should have no actionable events, got %d alerts", sumB.Total()) 185 } 186 listB, err := svc.ListAlerts(ctxOrg(orgB), "") 187 if err != nil { 188 t.Fatalf("list org B alerts: %v", err) 189 } 190 if len(listB) != 0 { 191 t.Fatalf("ISOLATION BREACH: org B saw %d alerts (org A's?)", len(listB)) 192 } 193 // A direct read of org A's clearance alert under org B's session must return zero rows (RLS hides it). 194 var n int 195 if err := appDB.RunInTenantTx(ctxOrg(orgB), func(ctx context.Context, tx pgx.Tx) error { 196 return tx.QueryRow(ctx, "SELECT count(*) FROM alerts WHERE id = $1", ca.ID).Scan(&n) 197 }); err != nil { 198 t.Fatalf("cross tenant read: %v", err) 199 } 200 if n != 0 { 201 t.Fatalf("ISOLATION BREACH: org B read org A's alert by id (count %d)", n) 202 } 203 204 // SetAlertStatus flips unread to dismissed under RLS. 205 if ca.Status != alerts.StatusUnread { 206 t.Fatalf("a fresh alert must be unread, got %s", ca.Status) 207 } 208 updated, err := svc.SetAlertStatus(ctxOrg(orgA), uuid.MustParse(ca.ID), alerts.StatusDismissed) 209 if err != nil { 210 t.Fatalf("set alert status: %v", err) 211 } 212 if updated.Status != alerts.StatusDismissed { 213 t.Fatalf("status after dismiss = %s, want dismissed", updated.Status) 214 } 215 // The dismissed status survives a re sweep (the upsert refreshes the content but leaves the status). 216 if _, err := svc.SweepOrg(ctxOrg(orgA)); err != nil { 217 t.Fatalf("third sweep org A: %v", err) 218 } 219 dismissed, err := svc.ListAlerts(ctxOrg(orgA), alerts.StatusDismissed) 220 if err != nil { 221 t.Fatalf("list dismissed alerts: %v", err) 222 } 223 if len(dismissed) != 1 || dismissed[0].ID != ca.ID { 224 t.Fatalf("the dismissed alert must persist across a re sweep, got %d dismissed", len(dismissed)) 225 } 226} 227