Janady13/missionmatch / internal/modules/ai/graph_wage_test.go

1package ai 2 3import ( 4 "strings" 5 "testing" 6 7 "github.com/shopspring/decimal" 8) 9 10// TestResolveAreaMapsKnownStates pins the conservative area resolver: a work_location naming Hawaii, HI, or a 11// Hawaii city maps to HI; New Mexico, NM, or a New Mexico city maps to NM; an unknown state maps to nothing so 12// the honest floor holds. The two letter abbreviation is matched only as a delimited token so a stray 13// substring never false matches. 14func TestResolveAreaMapsKnownStates(t *testing.T) { 15 cases := []struct { 16 in string 17 wantArea string 18 wantOK bool 19 }{ 20 {"Honolulu, Hawaii", "HI", true}, 21 {"Honolulu, HI", "HI", true}, 22 {"hawaii", "HI", true}, 23 {"Pearl Harbor, HI", "HI", true}, 24 {"Albuquerque, New Mexico", "NM", true}, 25 {"Kirtland AFB, NM", "NM", true}, 26 {"new mexico", "NM", true}, 27 {"Fort Bragg, NC", "", false}, 28 {"Arlington, Virginia", "", false}, 29 {"Remote", "", false}, 30 {"", "", false}, 31 // A stray "hi" or "nm" inside a longer word must NOT false match (delimited token only). 32 {"Chicago, IL", "", false}, 33 {"Manhattan, NY", "", false}, 34 } 35 for _, c := range cases { 36 gotArea, gotOK := resolveArea(c.in) 37 if gotArea != c.wantArea || gotOK != c.wantOK { 38 t.Errorf("resolveArea(%q) = (%q, %v), want (%q, %v)", c.in, gotArea, gotOK, c.wantArea, c.wantOK) 39 } 40 } 41} 42 43// TestResolveSOCMatchesTheCuratedCrosswalk pins the conservative role to SOC resolver over the existing 44// bls.GalapagosOccupations crosswalk: a title naming a Galapagos role or the OEWS occupation title resolves to 45// that occupation's SOC; an unmatchable title resolves to nothing so the honest floor holds. It reuses the ONE 46// curated crosswalk, never inventing a new one. 47func TestResolveSOCMatchesTheCuratedCrosswalk(t *testing.T) { 48 cases := []struct { 49 title string 50 wantSOC string 51 wantOK bool 52 }{ 53 {"Program Manager", "113021", true}, 54 {"Senior Program Manager, Space Systems", "113021", true}, 55 {"Systems Engineer", "151252", true}, 56 {"ISSO and Cyber", "151212", true}, 57 {"Information Security Analysts", "151212", true}, // matches by OEWS title 58 {"Help Desk and IT Specialist", "151232", true}, 59 {"Space and Cyber Architect", "151241", true}, 60 {"Janitor", "", false}, 61 {"Registered Nurse", "", false}, 62 {"", "", false}, 63 } 64 for _, c := range cases { 65 occ, ok := resolveSOC(c.title) 66 if ok != c.wantOK { 67 t.Errorf("resolveSOC(%q) ok = %v, want %v", c.title, ok, c.wantOK) 68 continue 69 } 70 if ok && occ.SOC != c.wantSOC { 71 t.Errorf("resolveSOC(%q) SOC = %q, want %q", c.title, occ.SOC, c.wantSOC) 72 } 73 } 74} 75 76// TestResolveSOCBroadenedMatchesTheIngestedOEWSSet pins the broadened, conservative title to SOC resolver 77// over an in memory ingested national OEWS occupation set (the M5 Phase 1 expansion beyond the five curated 78// Galapagos roles). A requirement title that contains exactly one OEWS occupation title resolves to that 79// SOC; the LONGEST occupation title wins when several overlap (the most specific occupation); a title that 80// matches two DIFFERENT SOCs at the same longest length is ambiguous and returns false so the honest floor 81// holds; an unmatchable title and an empty occupation set return false. It never fabricates a SOC. 82func TestResolveSOCBroadenedMatchesTheIngestedOEWSSet(t *testing.T) { 83 occs := []nationalOccupation{ 84 {SOC: "151212", Title: "Information Security Analysts"}, 85 {SOC: "151252", Title: "Software Developers"}, 86 {SOC: "172112", Title: "Industrial Engineers"}, 87 {SOC: "172141", Title: "Mechanical Engineers"}, 88 {SOC: "119041", Title: "Architectural and Engineering Managers"}, 89 } 90 cases := []struct { 91 name string 92 title string 93 wantSOC string 94 wantOK bool 95 }{ 96 {"contains one occupation title", "Senior Information Security Analysts, Cyber", "151212", true}, 97 {"exact occupation title", "Mechanical Engineers", "172141", true}, 98 {"longest match wins over a shorter contained span", "Architectural and Engineering Managers", "119041", true}, 99 {"unmatchable title keeps the floor", "Underwater Basket Weaver", "", false}, 100 {"empty title returns false", "", "", false}, 101 } 102 for _, c := range cases { 103 t.Run(c.name, func(t *testing.T) { 104 occ, ok := resolveSOCBroadened(c.title, occs) 105 if ok != c.wantOK { 106 t.Fatalf("resolveSOCBroadened(%q) ok = %v, want %v", c.title, ok, c.wantOK) 107 } 108 if ok && occ.SOC != c.wantSOC { 109 t.Errorf("resolveSOCBroadened(%q) SOC = %q, want %q", c.title, occ.SOC, c.wantSOC) 110 } 111 }) 112 } 113 114 // An ambiguous title that matches two DIFFERENT SOCs at the same longest length returns false. Both 115 // "Data Scientists" entries below share the same title length but distinct SOCs, so the tie degrades to 116 // the honest floor rather than binding one arbitrarily. 117 ambiguous := []nationalOccupation{ 118 {SOC: "152051", Title: "Data Scientists"}, 119 {SOC: "152098", Title: "Data Scientists"}, 120 } 121 if _, ok := resolveSOCBroadened("Senior Data Scientists", ambiguous); ok { 122 t.Error("a title matching two different SOCs at the same length must return false") 123 } 124 125 // An empty occupation set returns false (an unpopulated catalog degrades to the honest floor). 126 if _, ok := resolveSOCBroadened("Mechanical Engineers", nil); ok { 127 t.Error("an empty occupation set must return false") 128 } 129} 130 131// TestNationalOccupationsSQLPassesTheReadOnlyGuard proves the broadened national occupation read passes 132// GuardReadOnlyQuery against the real ReadAllowlist: a single read over the allowlisted bls_wages table with 133// no mutating keyword, the same gate the wage band read passes. 134func TestNationalOccupationsSQLPassesTheReadOnlyGuard(t *testing.T) { 135 if err := GuardReadOnlyQuery(nationalOccupationsSQL, ReadAllowlist); err != nil { 136 t.Fatalf("the national occupations SQL must pass the read only guard: %v", err) 137 } 138} 139 140// TestCapturePriceToWinLineFallsBackToOccupationTitleForNational proves the surfaced line names the OEWS 141// occupation title when the band carries an empty role (the national rows), so a national band still names 142// its occupation, and it names United States as the area. It carries no dash in surfaced prose. 143func TestCapturePriceToWinLineFallsBackToOccupationTitleForNational(t *testing.T) { 144 band := WageBand{ 145 SOC: "172141", 146 OccupationTitle: "Mechanical Engineers", 147 Role: "", // a national row carries no Galapagos role 148 Area: "US", 149 AreaName: "United States", 150 AnnualMean: decimal.RequireFromString("102000.00"), 151 AnnualMedian: decimal.RequireFromString("97000.00"), 152 } 153 got := capturePriceToWinLine(band) 154 for _, want := range []string{"Mechanical Engineers", "United States", "$102000.00", "$97000.00", "BLS OEWS", "advisory"} { 155 if !strings.Contains(got, want) { 156 t.Errorf("the national price to win line must contain %q, got %q", want, got) 157 } 158 } 159 if strings.Contains(got, "-") { 160 t.Errorf("the price to win line must carry no dash in surfaced prose, got %q", got) 161 } 162} 163 164// TestLaborRateBandSQLPassesTheReadOnlyGuard is the load bearing security assertion for M5: the wage band SQL 165// passes GuardReadOnlyQuery against the real ReadAllowlist with no error. It must be a single read over the 166// allowlisted bls_wages table with no mutating keyword and no eeo marker, the same gate ValidateRegistry runs 167// at boot and ExecuteIntent would re run. 168func TestLaborRateBandSQLPassesTheReadOnlyGuard(t *testing.T) { 169 if err := GuardReadOnlyQuery(laborRateBandSQL, ReadAllowlist); err != nil { 170 t.Fatalf("the labor rate band SQL must pass the read only guard: %v", err) 171 } 172} 173 174// TestValidateRegistryWithLaborRateBand proves the whole closed Registry, now carrying the M5 labor rate band 175// intent, validates at boot. ValidateRegistry runs GuardReadOnlyQuery on every intent's SQL, so the new 176// intent's SQL must itself pass the guard for the whole Registry to validate. 177func TestValidateRegistryWithLaborRateBand(t *testing.T) { 178 if err := ValidateRegistry(); err != nil { 179 t.Fatalf("ValidateRegistry must pass with the M5 labor rate band intent registered: %v", err) 180 } 181} 182 183// TestLaborRateBandIntentIsRegistered proves labor_rate_band is in the closed Registry binding a role or SOC 184// text param and an area enum bounded to HI and NM, and is a graph intent (so Answer routes it to AnswerGraph) 185// but NOT a bench intent (it is public reference data, never suppressed). 186func TestLaborRateBandIntentIsRegistered(t *testing.T) { 187 it, ok := IntentByName(IntentLaborRateBand) 188 if !ok { 189 t.Fatalf("intent %q must be registered in the closed Registry", IntentLaborRateBand) 190 } 191 if len(it.Params) != 2 { 192 t.Fatalf("the labor rate band intent must bind exactly two params, got %d", len(it.Params)) 193 } 194 if it.Params[1].Kind != ParamEnum { 195 t.Errorf("the area param must be an enum, got %q", it.Params[1].Kind) 196 } 197 for _, want := range []string{"HI", "NM"} { 198 if !allowedValue(want, it.Params[1].Allowed) { 199 t.Errorf("the area enum must allow %q", want) 200 } 201 } 202 if !IsGraphIntent(IntentLaborRateBand) { 203 t.Error("the labor rate band intent must be a graph intent so Answer routes it to AnswerGraph") 204 } 205 if IsBenchIntent(IntentLaborRateBand) { 206 t.Error("the labor rate band intent reads public reference data and must NOT be a bench intent") 207 } 208} 209 210// TestWageClassifierBindsOnlyOnResolvableRoleAndState pins the conservative NL posture: a labor rate question 211// routes to the wage intent ONLY when it carries both a quoted role we can resolve to a SOC and a named state 212// we can resolve to a known OEWS area; an unresolvable role or an unknown state falls back to RAG (a nil 213// route) rather than guessing a rate. 214func TestWageClassifierBindsOnlyOnResolvableRoleAndState(t *testing.T) { 215 gr := graphClassify(`what is the labor rate for a "Program Manager" in Hawaii`) 216 if gr == nil { 217 t.Fatal("a labor rate question with a resolvable role and state must route to the wage intent") 218 } 219 if gr.intent != IntentLaborRateBand { 220 t.Errorf("the wage question must route to %q, got %q", IntentLaborRateBand, gr.intent) 221 } 222 if len(gr.args) != 2 || gr.args[0] != "113021" || gr.args[1] != "HI" { 223 t.Errorf("the wage route must bind the resolved SOC and area, got %v", gr.args) 224 } 225 226 // A wage question with a resolvable role but an unknown state falls back to RAG. 227 if got := graphClassify(`prevailing wage for a "Program Manager" in Virginia`); got != nil { 228 t.Errorf("a wage question in a state with no wage data must fall back to RAG, got %+v", got) 229 } 230 // A wage question with a known state but an unresolvable quoted role falls back to RAG. 231 if got := graphClassify(`labor rate for a "Underwater Basket Weaver" in Hawaii`); got != nil { 232 t.Errorf("a wage question with an unresolvable role must fall back to RAG, got %+v", got) 233 } 234 // A wage question with no quoted role at all falls back to RAG (a bare role is ambiguous). 235 if got := graphClassify(`what is the labor rate for a program manager in Hawaii`); got != nil { 236 t.Errorf("a wage question with no quoted role must fall back to RAG, got %+v", got) 237 } 238} 239 240// TestCapturePriceToWinLineNamesTheBandAndNeverADash pins the surfaced price to win line rendered from a 241// resolved wage band: it names the role, the area name, the annual mean and annual median in dollars to cents, 242// labels the source BLS OEWS advisory, and carries no dash in surfaced prose (the platform writing rule). 243func TestCapturePriceToWinLineNamesTheBandAndNeverADash(t *testing.T) { 244 band := WageBand{ 245 SOC: "113021", 246 OccupationTitle: "Computer and Information Systems Managers", 247 Role: "Program Manager", 248 Area: "HI", 249 AreaName: "Hawaii", 250 AnnualMean: decimal.RequireFromString("185000.00"), 251 AnnualMedian: decimal.RequireFromString("172500.50"), 252 } 253 got := capturePriceToWinLine(band) 254 for _, want := range []string{"Program Manager", "Hawaii", "$185000.00", "$172500.50", "BLS OEWS", "advisory"} { 255 if !strings.Contains(got, want) { 256 t.Errorf("the price to win line must contain %q, got %q", want, got) 257 } 258 } 259 if strings.Contains(got, "-") { 260 t.Errorf("the price to win line must carry no dash in surfaced prose, got %q", got) 261 } 262} 263