Janady13/missionmatch / internal/modules/staffing/classify_test.go

1package staffing 2 3import ( 4 "testing" 5 6 "github.com/shopspring/decimal" 7 8 "github.com/missionworkforce/missionmatch/internal/modules/matching/engine" 9) 10 11func bandFor(total decimal.Decimal) engine.Band { 12 switch { 13 case total.GreaterThanOrEqual(decimal.NewFromInt(90)): 14 return engine.BandGreen 15 case total.GreaterThanOrEqual(decimal.NewFromInt(75)): 16 return engine.BandYellow 17 default: 18 return engine.BandRed 19 } 20} 21 22func cand(id, total string, available, clearanceOK bool) ScoredCandidate { 23 return ScoredCandidate{ 24 CandidateID: id, 25 Total: dec(total), 26 Band: bandFor(dec(total)), 27 Available: available, 28 ClearanceSatisfied: clearanceOK, 29 Provenance: "sponsor_verified", 30 Completeness: dec("1"), 31 } 32} 33 34func gapCtx(openSlots int, priority string) GapContext { 35 return GapContext{RequirementID: "req-gap", OpenSlots: openSlots, Priority: dec(priority)} 36} 37 38func countAction(recs []Recommendation, a Action) int { 39 n := 0 40 for _, r := range recs { 41 if r.Action == a { 42 n++ 43 } 44 } 45 return n 46} 47 48func TestClassifyAssignBasic(t *testing.T) { 49 cfg := DefaultConfig() 50 recs := ClassifyForGap(cfg, gapCtx(2, "1"), []ScoredCandidate{cand("c1", "92", true, true)}) 51 if len(recs) != 2 { // one assign, one source (2 slots, 1 assignable) 52 t.Fatalf("want 2 recs (assign + source), got %d", len(recs)) 53 } 54 if recs[0].Action != ActionAssign || recs[0].CandidateID != "c1" || recs[0].Rank != 1 { 55 t.Fatalf("first rec must be the assign for c1 at rank 1: %+v", recs[0]) 56 } 57 if recs[0].RequirementID != "req-gap" { 58 t.Fatalf("recommendation must carry the gap requirement id, got %q", recs[0].RequirementID) 59 } 60} 61 62func TestClassifyBandFloorBoundary(t *testing.T) { 63 cfg := DefaultConfig() // floor 75 64 // Exactly at the floor is qualified (>=). 65 atFloor := ClassifyForGap(cfg, gapCtx(1, "1"), []ScoredCandidate{cand("c1", "75", true, true)}) 66 if countAction(atFloor, ActionAssign) != 1 { 67 t.Fatalf("a candidate exactly at the floor must be assignable") 68 } 69 // Just below the floor with a reskill path is a reskill, not an assign. 70 below := cand("c2", "74.9999", true, true) 71 below.Reskill = &ReskillFact{HeldSkill: "SIGINT Tooling", MissingSkill: "Intelligence Analysis", Distance: dec("0.20")} 72 belowRecs := ClassifyForGap(cfg, gapCtx(1, "1"), []ScoredCandidate{below}) 73 if countAction(belowRecs, ActionAssign) != 0 { 74 t.Fatalf("a candidate below the floor must never be an assign") 75 } 76 if countAction(belowRecs, ActionReskill) != 1 { 77 t.Fatalf("a below floor candidate with an adjacency path must be a reskill") 78 } 79 // Just below the floor with NO reskill path produces no row for that candidate (never auto rejected). 80 bare := cand("c3", "74.9999", true, true) 81 bareRecs := ClassifyForGap(cfg, gapCtx(1, "1"), []ScoredCandidate{bare}) 82 for _, r := range bareRecs { 83 if r.CandidateID == "c3" { 84 t.Fatalf("a below floor candidate with no reskill path must not appear as any recommendation, got %+v", r) 85 } 86 } 87} 88 89func TestClassifyReassign(t *testing.T) { 90 cfg := DefaultConfig() 91 // Committed to a lower priority requirement -> reassign with the delta. 92 c := cand("c1", "95", true, true) 93 c.CommittedRequirementID = "req-other" 94 c.CommittedPriority = dec("1") 95 recs := ClassifyForGap(cfg, gapCtx(1, "2.5"), []ScoredCandidate{c}) 96 if countAction(recs, ActionReassign) != 1 { 97 t.Fatalf("a qualified candidate committed to a lower priority requirement must be a reassign") 98 } 99 var rr *Recommendation 100 for i := range recs { 101 if recs[i].Action == ActionReassign { 102 rr = &recs[i] 103 } 104 } 105 if rr.Evidence.Reassign == nil || rr.Evidence.Reassign.FromRequirementID != "req-other" { 106 t.Fatalf("reassign evidence must name the source requirement: %+v", rr.Evidence) 107 } 108 if !rr.Evidence.Reassign.PriorityDelta.Equal(dec("1.5")) { 109 t.Fatalf("priority delta must be 2.5 - 1 = 1.5, got %s", rr.Evidence.Reassign.PriorityDelta) 110 } 111 // Committed to an equal or higher priority requirement -> not recommended (leave them where they are). 112 c.CommittedPriority = dec("2.5") 113 none := ClassifyForGap(cfg, gapCtx(1, "2.5"), []ScoredCandidate{c}) 114 if countAction(none, ActionReassign) != 0 { 115 t.Fatalf("a candidate committed at equal priority must not be reassigned") 116 } 117} 118 119func TestClassifyCommittedToSameGapIsAssign(t *testing.T) { 120 cfg := DefaultConfig() 121 c := cand("c1", "95", true, true) 122 c.CommittedRequirementID = "req-gap" // already committed to this very gap 123 c.CommittedPriority = dec("1") 124 recs := ClassifyForGap(cfg, gapCtx(1, "2"), []ScoredCandidate{c}) 125 if countAction(recs, ActionAssign) != 1 || countAction(recs, ActionReassign) != 0 { 126 t.Fatalf("a candidate committed to the gap itself is an assign, not a reassign: %+v", recs) 127 } 128} 129 130func TestClassifyReskillGating(t *testing.T) { 131 cfg := DefaultConfig() 132 base := cand("c1", "60", true, true) 133 base.Reskill = &ReskillFact{HeldSkill: "Python", MissingSkill: "Go", Distance: dec("0.30")} 134 if countAction(ClassifyForGap(cfg, gapCtx(1, "1"), []ScoredCandidate{base}), ActionReskill) != 1 { 135 t.Fatalf("a below floor, clearance satisfied, available candidate with an adjacency path must reskill") 136 } 137 // No adjacency path -> no reskill. 138 noAdj := cand("c2", "60", true, true) 139 if len(ClassifyForGap(cfg, gapCtx(0, "1"), []ScoredCandidate{noAdj})) != 0 { 140 t.Fatalf("no adjacency path means no reskill and no row") 141 } 142 // Clearance not satisfied -> no reskill even with an adjacency path (clearance is a hard gate). 143 noClear := cand("c3", "60", true, false) 144 noClear.Reskill = &ReskillFact{HeldSkill: "Python", MissingSkill: "Go", Distance: dec("0.30")} 145 if countAction(ClassifyForGap(cfg, gapCtx(0, "1"), []ScoredCandidate{noClear}), ActionReskill) != 0 { 146 t.Fatalf("a reskill must require the clearance gate to be satisfied") 147 } 148} 149 150func TestClassifySource(t *testing.T) { 151 cfg := DefaultConfig() 152 // Three open slots, one assignable -> one source note for the remaining two. 153 recs := ClassifyForGap(cfg, gapCtx(3, "1"), []ScoredCandidate{cand("c1", "92", true, true)}) 154 if countAction(recs, ActionSource) != 1 { 155 t.Fatalf("an under filled gap must emit exactly one source note") 156 } 157 var src *Recommendation 158 for i := range recs { 159 if recs[i].Action == ActionSource { 160 src = &recs[i] 161 } 162 } 163 if src.CandidateID != "" { 164 t.Fatalf("a source recommendation must name no candidate, got %q", src.CandidateID) 165 } 166 if src.Evidence.OpenSlots == nil || *src.Evidence.OpenSlots != 2 { 167 t.Fatalf("source must record the remaining open slots (2), got %+v", src.Evidence.OpenSlots) 168 } 169 if !src.Confidence.Equal(decimal.NewFromInt(1)) { 170 t.Fatalf("a source note is a deterministic fact, confidence 1, got %s", src.Confidence) 171 } 172 // Enough assignable for the slots -> no source. 173 full := ClassifyForGap(cfg, gapCtx(1, "1"), []ScoredCandidate{cand("c1", "92", true, true), cand("c2", "88", true, true)}) 174 if countAction(full, ActionSource) != 0 { 175 t.Fatalf("a fully coverable gap must not emit a source note") 176 } 177} 178 179func TestClassifyRankingDeterministic(t *testing.T) { 180 cfg := DefaultConfig() 181 in := []ScoredCandidate{ 182 cand("c-low", "80", true, true), 183 cand("c-hi", "95", true, true), 184 cand("c-mid-b", "85", true, true), 185 cand("c-mid-a", "85", true, true), // tie with c-mid-b, breaks by candidate id asc 186 } 187 recs := ClassifyForGap(cfg, gapCtx(4, "1"), in) 188 wantOrder := []string{"c-hi", "c-mid-a", "c-mid-b", "c-low"} 189 got := make([]string, 0, len(wantOrder)) 190 for _, r := range recs { 191 if r.Action == ActionAssign { 192 got = append(got, r.CandidateID) 193 } 194 } 195 for i, w := range wantOrder { 196 if got[i] != w { 197 t.Fatalf("ranking not deterministic: got %v want %v", got, wantOrder) 198 } 199 if recs[i].Rank != i+1 { 200 t.Fatalf("ranks must be 1 based sequential, got %d at index %d", recs[i].Rank, i) 201 } 202 } 203} 204 205func TestClassifyUnavailableQualifiedIsNotAssigned(t *testing.T) { 206 cfg := DefaultConfig() 207 recs := ClassifyForGap(cfg, gapCtx(1, "1"), []ScoredCandidate{cand("c1", "95", false, true)}) 208 if countAction(recs, ActionAssign) != 0 { 209 t.Fatalf("an unavailable candidate must not be assigned") 210 } 211 // The slot stays open, so a source note is emitted. 212 if countAction(recs, ActionSource) != 1 { 213 t.Fatalf("the unfilled slot must surface as a source note") 214 } 215} 216