Janady13/missionmatch / internal/integration/staffing_integration_test.go

1//go:build integration 2 3package integration 4 5import ( 6 "context" 7 "errors" 8 "testing" 9 10 "github.com/google/uuid" 11 "github.com/jackc/pgx/v5" 12 13 "github.com/missionworkforce/missionmatch/internal/modules/sourcing" 14 "github.com/missionworkforce/missionmatch/internal/modules/staffing" 15 "github.com/missionworkforce/missionmatch/internal/platform/audit" 16 "github.com/missionworkforce/missionmatch/internal/platform/tenant" 17) 18 19// newStaffingSvc builds the W3 service against the live app pool with an exact only matcher (nil) and NO 20// inference client, so every rationale takes the deterministic fallback (the faithfulness fallback path). 21func newStaffingSvc() *staffing.Service { 22 return staffing.NewService(appDB, nil, audit.New(appDB), nil, staffing.DefaultConfig()) 23} 24 25func seedW3User(t *testing.T, org uuid.UUID) context.Context { 26 t.Helper() 27 var userID uuid.UUID 28 if err := migrator.QueryRow(context.Background(), 29 `INSERT INTO users (organization_id, email, full_name, role, status) 30 VALUES ($1, $2, 'W3 Tester', 'owner', 'active') RETURNING id`, 31 org, "w3-"+org.String()[:8]+"@example.com").Scan(&userID); err != nil { 32 t.Fatalf("seed user: %v", err) 33 } 34 return tenant.WithUser(tenant.WithOrg(context.Background(), org.String()), tenant.Principal{UserID: userID.String(), Role: "owner"}) 35} 36 37func seedReq(t *testing.T, org uuid.UUID, level string, years, quantity int32) uuid.UUID { 38 t.Helper() 39 var id uuid.UUID 40 if err := migrator.QueryRow(context.Background(), 41 `INSERT INTO requirements (organization_id, title, labor_category, quantity, required_level, required_poly, required_years) 42 VALUES ($1, 'W3 Role', 'W3 Role', $2, $3, 'none', $4) RETURNING id`, 43 org, quantity, level, years).Scan(&id); err != nil { 44 t.Fatalf("seed requirement: %v", err) 45 } 46 return id 47} 48 49// TestStaffingGapEndToEnd proves the gap view: a qualified, available candidate becomes an ASSIGN and the 50// unfilled slot becomes a SOURCE note, every non source recommendation references a real frozen 51// candidate_evaluations row, the run is audited, and (with no inference client) the rationale takes the 52// deterministic fallback while the recommendation still stands. 53func TestStaffingGapEndToEnd(t *testing.T) { 54 ctx := context.Background() 55 org := seedOrg(t) 56 userCtx := seedW3User(t, org) 57 req := seedReq(t, org, "secret", 5, 2) // two open slots 58 59 strong := seedCandidate(t, org, "secret", "active", true) 60 if _, err := migrator.Exec(ctx, "UPDATE candidates SET years_experience=10 WHERE id=$1", strong.ID); err != nil { 61 t.Fatalf("enrich strong: %v", err) 62 } 63 seedCandidate(t, org, "none", "active", true) // below the floor (no clearance), no reskill path 64 65 svc := newStaffingSvc() 66 out, err := svc.GenerateGap(userCtx, req, staffing.GapRequest{}) 67 if err != nil { 68 t.Fatalf("GenerateGap: %v", err) 69 } 70 71 var assign, source int 72 for _, r := range out.Recommendations { 73 switch r.Action { 74 case "assign": 75 assign++ 76 if r.CandidateID != strong.ID.String() { 77 t.Fatalf("assign should be the strong candidate, got %s", r.CandidateID) 78 } 79 if r.RationaleSource != "deterministic" || r.Rationale == "" { 80 t.Fatalf("with no plane the rationale must be a non empty deterministic fallback, got source=%s rationale=%q", r.RationaleSource, r.Rationale) 81 } 82 // Every non source recommendation references a real frozen evaluation. 83 assertEvaluationExists(t, org, strong.ID, req) 84 case "source": 85 source++ 86 if r.CandidateID != "" { 87 t.Fatalf("a source recommendation must name no candidate, got %s", r.CandidateID) 88 } 89 } 90 } 91 if assign != 1 || source != 1 { 92 t.Fatalf("want 1 assign + 1 source, got assign=%d source=%d (%d recs)", assign, source, len(out.Recommendations)) 93 } 94 95 // The run is audited (no PII), and the served score for the surfaced candidate is recorded. 96 assertAuditCount(t, org, "aedt.staffing.recommended", 1) 97 if n := auditCount(t, org, "aedt.score.served"); n < 1 { 98 t.Fatalf("want at least one served score audit, got %d", n) 99 } 100} 101 102// TestStaffingPortfolioEndToEnd proves the portfolio optimizer allocates the available bench across open 103// requirements, each assignment carrying a scaled value and a counterfactual. 104func TestStaffingPortfolioEndToEnd(t *testing.T) { 105 org := seedOrg(t) 106 userCtx := seedW3User(t, org) 107 seedReq(t, org, "secret", 0, 1) // two open single slot requirements; the portfolio reads all open ones 108 seedReq(t, org, "secret", 0, 1) 109 c1 := seedCandidate(t, org, "secret", "active", true) 110 c2 := seedCandidate(t, org, "secret", "active", true) 111 112 svc := newStaffingSvc() 113 out, err := svc.GeneratePortfolio(userCtx, staffing.PortfolioRequest{}) 114 if err != nil { 115 t.Fatalf("GeneratePortfolio: %v", err) 116 } 117 assigns := 0 118 assigned := map[string]bool{} 119 for _, r := range out.Recommendations { 120 if r.Action != "assign" { 121 continue 122 } 123 assigns++ 124 assigned[r.CandidateID] = true 125 if r.ValueScore == nil || *r.ValueScore <= 0 { 126 t.Fatalf("a portfolio assign must carry a positive scaled value, got %+v", r.ValueScore) 127 } 128 if len(r.Evidence) == 0 { 129 t.Fatalf("a portfolio assign must carry counterfactual evidence") 130 } 131 } 132 if assigns != 2 || !assigned[c1.ID.String()] || !assigned[c2.ID.String()] { 133 t.Fatalf("both candidates should be allocated to the two open slots, got %d assigns %v", assigns, assigned) 134 } 135 assertAuditCount(t, org, "aedt.staffing.recommended", 1) 136} 137 138// TestStaffingProactiveEndToEnd proves the proactive recompute writes a bench watch the read endpoint 139// returns. 140func TestStaffingProactiveEndToEnd(t *testing.T) { 141 org := seedOrg(t) 142 seedReq(t, org, "secret", 0, 1) 143 cand := seedCandidate(t, org, "secret", "active", true) 144 145 svc := newStaffingSvc() 146 n, err := svc.RecomputeProactive(ctxOrg(org)) 147 if err != nil { 148 t.Fatalf("RecomputeProactive: %v", err) 149 } 150 if n < 1 { 151 t.Fatalf("expected at least one candidate watch, got %d", n) 152 } 153 pr, err := svc.ListProactive(ctxOrg(org), 0, 0) 154 if err != nil { 155 t.Fatalf("ListProactive: %v", err) 156 } 157 found := false 158 for _, r := range pr.Recommendations { 159 if r.CandidateID == cand.ID.String() && r.Action == "assign" && r.Status == "pending" { 160 found = true 161 } 162 } 163 if !found { 164 t.Fatalf("the available candidate must appear in the bench watch, got %+v", pr.Recommendations) 165 } 166} 167 168// TestStaffingDecisionAndConflict proves the human in the loop decision path: a pending recommendation can 169// be approved once, a second decision returns 409 (never overwriting a decided row), the decision is 170// audited, and nothing is auto rejected. 171func TestStaffingDecisionAndConflict(t *testing.T) { 172 org := seedOrg(t) 173 userCtx := seedW3User(t, org) 174 req := seedReq(t, org, "secret", 5, 1) 175 strong := seedCandidate(t, org, "secret", "active", true) 176 if _, err := migrator.Exec(context.Background(), "UPDATE candidates SET years_experience=10 WHERE id=$1", strong.ID); err != nil { 177 t.Fatalf("enrich strong: %v", err) 178 } 179 180 svc := newStaffingSvc() 181 out, err := svc.GenerateGap(userCtx, req, staffing.GapRequest{}) 182 if err != nil { 183 t.Fatalf("GenerateGap: %v", err) 184 } 185 var assignID uuid.UUID 186 for _, r := range out.Recommendations { 187 if r.Action == "assign" { 188 assignID = uuid.MustParse(r.ID) 189 } 190 if r.Status != "pending" { 191 t.Fatalf("a fresh recommendation must be pending (never auto decided), got %s for %s", r.Status, r.Action) 192 } 193 } 194 if assignID == uuid.Nil { 195 t.Fatal("no assign recommendation to decide") 196 } 197 198 if _, err := svc.Decide(userCtx, assignID, staffing.DecisionRequest{Decision: "approved", Note: "strong fit"}); err != nil { 199 t.Fatalf("first decision should succeed: %v", err) 200 } 201 // A second decision on the now decided row must conflict, not silently overwrite. 202 if _, err := svc.Decide(userCtx, assignID, staffing.DecisionRequest{Decision: "rejected"}); !errors.Is(err, staffing.ErrConflict) { 203 t.Fatalf("second decision must return ErrConflict, got %v", err) 204 } 205 assertAuditCount(t, org, "aedt.staffing.decided", 1) 206} 207 208// TestStaffingErasureRemovesRecommendations proves the right to erasure: anonymizing a candidate removes 209// their staffing recommendations (the FK cascade does not fire on anonymize in place, so the cleanup is 210// explicit). 211func TestStaffingErasureRemovesRecommendations(t *testing.T) { 212 org := seedOrg(t) 213 userCtx := seedW3User(t, org) 214 req := seedReq(t, org, "secret", 5, 1) 215 strong := seedCandidate(t, org, "secret", "active", true) 216 if _, err := migrator.Exec(context.Background(), "UPDATE candidates SET years_experience=10 WHERE id=$1", strong.ID); err != nil { 217 t.Fatalf("enrich strong: %v", err) 218 } 219 220 svc := newStaffingSvc() 221 if _, err := svc.GenerateGap(userCtx, req, staffing.GapRequest{}); err != nil { 222 t.Fatalf("GenerateGap: %v", err) 223 } 224 if n := recCountForCandidate(t, org, strong.ID); n < 1 { 225 t.Fatalf("expected at least one recommendation for the candidate before erasure, got %d", n) 226 } 227 228 if err := sourcing.NewService(appDB, audit.New(appDB)).Delete(userCtx, strong.ID); err != nil { 229 t.Fatalf("erasure: %v", err) 230 } 231 if n := recCountForCandidate(t, org, strong.ID); n != 0 { 232 t.Fatalf("erasure must remove the candidate's recommendations, %d remain", n) 233 } 234} 235 236// ---------- assertions ---------- 237 238func assertEvaluationExists(t *testing.T, org, cand, req uuid.UUID) { 239 t.Helper() 240 var n int 241 if err := appDB.RunInTenantTx(ctxOrg(org), func(ctx context.Context, tx pgx.Tx) error { 242 return tx.QueryRow(ctx, "SELECT count(*) FROM candidate_evaluations WHERE candidate_id=$1 AND requirement_id=$2", cand, req).Scan(&n) 243 }); err != nil { 244 t.Fatalf("count evaluations: %v", err) 245 } 246 if n != 1 { 247 t.Fatalf("recommendation must reference exactly one frozen evaluation for (cand, req), got %d", n) 248 } 249} 250 251func auditCount(t *testing.T, org uuid.UUID, action string) int { 252 t.Helper() 253 var n int 254 if err := appDB.RunInTenantTx(ctxOrg(org), func(ctx context.Context, tx pgx.Tx) error { 255 return tx.QueryRow(ctx, "SELECT count(*) FROM audit_logs WHERE organization_id=$1 AND action=$2", org, action).Scan(&n) 256 }); err != nil { 257 t.Fatalf("count audits %s: %v", action, err) 258 } 259 return n 260} 261 262func assertAuditCount(t *testing.T, org uuid.UUID, action string, want int) { 263 t.Helper() 264 if n := auditCount(t, org, action); n != want { 265 t.Fatalf("want %d %s audit events, got %d", want, action, n) 266 } 267} 268 269func recCountForCandidate(t *testing.T, org, cand uuid.UUID) int { 270 t.Helper() 271 var n int 272 if err := appDB.RunInTenantTx(ctxOrg(org), func(ctx context.Context, tx pgx.Tx) error { 273 return tx.QueryRow(ctx, "SELECT count(*) FROM staffing_recommendations WHERE candidate_id=$1", cand).Scan(&n) 274 }); err != nil { 275 t.Fatalf("count recs: %v", err) 276 } 277 return n 278} 279