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

1package ai 2 3import ( 4 "strings" 5 "testing" 6) 7 8// TestGraphTeamingIntentsAreRegistered proves the three G2 vendor co occurrence and teaming field traversals 9// are in the closed Registry, so ValidateRegistry asserts them at boot and ExecuteIntent can run them. A 10// missing intent means the registration regressed. 11func TestGraphTeamingIntentsAreRegistered(t *testing.T) { 12 cases := map[string]int{ 13 IntentVendorCooccurrenceField: 2, // agency, naics 14 IntentPartnerOrCompetitorRatio: 2, // partner_uei, naics 15 IntentRecompeteTeamingField: 2, // agency, window_months 16 } 17 for name, wantParams := range cases { 18 it, ok := IntentByName(name) 19 if !ok { 20 t.Fatalf("intent %q must be registered in the closed Registry", name) 21 } 22 if len(it.Params) != wantParams { 23 t.Errorf("intent %q must bind exactly %d params, got %d", name, wantParams, len(it.Params)) 24 } 25 } 26} 27 28// TestGraphTeamingIntentsPassTheReadOnlyGuard is the load bearing security assertion: each registered teaming 29// intent passes GuardReadOnlyQuery against the real ReadAllowlist. A query that referenced a non allowlisted 30// table, hid a mutation, or named an eeo marker would fail here, the same gate ValidateRegistry runs at boot 31// and ExecuteIntent re runs at execution time. 32func TestGraphTeamingIntentsPassTheReadOnlyGuard(t *testing.T) { 33 for _, sql := range []string{ 34 vendorCooccurrenceFieldSQL, 35 partnerOrCompetitorRatioSQL, 36 recompeteTeamingFieldSQL, 37 } { 38 if err := GuardReadOnlyQuery(sql, ReadAllowlist); err != nil { 39 t.Errorf("a registered teaming intent must pass the read only guard: %v", err) 40 } 41 } 42} 43 44// TestValidateRegistryWithTeamingIntents proves the whole closed Registry, now carrying the three G2 intents 45// alongside the TAG, G3, G1, G9, and G7 intents, validates at boot. This is the assertion the api boot runs. 46func TestValidateRegistryWithTeamingIntents(t *testing.T) { 47 if err := ValidateRegistry(); err != nil { 48 t.Fatalf("ValidateRegistry must pass with the three G2 teaming intents registered: %v", err) 49 } 50} 51 52// TestTeamingAwardsCooccurrenceKeysOnlyOnAgencyAndNaics is the honesty mandate, pinned statically: 53// usaspending_awards carries NO psc, NO set_aside, and NO pop_state column, so the awards co occurrence keys 54// ONLY on (awarding_agency, naics_code). No G2 read may select or join on those phantom columns against the 55// award alias. A regression that reached for a phantom award column would fail here. 56func TestTeamingAwardsCooccurrenceKeysOnlyOnAgencyAndNaics(t *testing.T) { 57 for name, sql := range map[string]string{ 58 "vendor_cooccurrence_field": vendorCooccurrenceFieldSQL, 59 "partner_or_competitor_ratio": partnerOrCompetitorRatioSQL, 60 "recompete_teaming_field": recompeteTeamingFieldSQL, 61 } { 62 lower := strings.ToLower(sql) 63 // The phantom columns the award table does NOT have. None may appear qualified to an award alias. 64 for _, phantom := range []string{"a.psc", "a.set_aside", "a.pop_state", "a.award_date", "inc.psc", "inc.set_aside", "inc.pop_state"} { 65 if strings.Contains(lower, phantom) { 66 t.Errorf("%s: usaspending_awards has no %s column; a G2 award read must not reference it", name, phantom) 67 } 68 } 69 } 70 // The vendor co occurrence awards arm keys on awarding_agency and naics_code, the only keys the award table 71 // carries; it must not key on a finer slice. 72 lower := strings.ToLower(vendorCooccurrenceFieldSQL) 73 if !strings.Contains(lower, "a.awarding_agency = $1") { 74 t.Error("the vendor co occurrence awards arm must key on awarding_agency") 75 } 76 if !strings.Contains(lower, "a.naics_code = $2") { 77 t.Error("the vendor co occurrence awards arm must key on naics_code") 78 } 79} 80 81// TestTeamingIntentsReferenceNoTenantTable is the Phase 1 scope boundary, pinned statically: G2 is PUBLIC 82// DATA ONLY. NONE of the three intents may name a tenant table (requirements, candidates, the bench, the eeo 83// schema). The tenant gap intersection questions (which partner closes OUR bench gap) are DEFERRED to Phase 2 84// and G6. The only tenant side these reads touch is the PUBLIC is_galapagos self tag on usaspending_awards, a 85// column on the public award catalog, never a tenant table. A regression that joined a tenant table would 86// fail here, the same boundary the read allowlist enforces. 87func TestTeamingIntentsReferenceNoTenantTable(t *testing.T) { 88 tenantTables := []string{ 89 "requirement_mission_tags", "requirements", "required_skills", 90 "candidate_mission_tags", "candidate_skills", "candidates", "candidate_evaluations", 91 "slates", "slate_members", "candidate_demographics", "eeo", 92 "tenant_mission_tags", "bench_import_log", 93 } 94 for name, sql := range map[string]string{ 95 "vendor_cooccurrence_field": vendorCooccurrenceFieldSQL, 96 "partner_or_competitor_ratio": partnerOrCompetitorRatioSQL, 97 "recompete_teaming_field": recompeteTeamingFieldSQL, 98 } { 99 lower := strings.ToLower(sql) 100 for _, tt := range tenantTables { 101 if strings.Contains(lower, "from "+tt) || strings.Contains(lower, "join "+tt) { 102 t.Errorf("%s: must not read the tenant or eeo table %q (Phase 1 is public data only)", name, tt) 103 } 104 } 105 } 106 // Positively confirm the partner ratio reaches the tenant side ONLY through the public is_galapagos self 107 // tag, never a tenant table. 108 if !strings.Contains(strings.ToLower(partnerOrCompetitorRatioSQL), "a.is_galapagos = true") { 109 t.Error("the partner ratio must reach the tenant side only through the public is_galapagos self tag") 110 } 111} 112 113// TestTeamingIntentsArePublicTablesOnly pins the public data mandate positively: every G2 intent reads ONLY 114// the global public market tables (opportunity_records, usaspending_awards). A regression that read anything 115// else would fail here. 116func TestTeamingIntentsArePublicTablesOnly(t *testing.T) { 117 publicTables := map[string]bool{ 118 "opportunity_records": true, 119 "usaspending_awards": true, 120 } 121 for name, sql := range map[string]string{ 122 "vendor_cooccurrence_field": vendorCooccurrenceFieldSQL, 123 "partner_or_competitor_ratio": partnerOrCompetitorRatioSQL, 124 "recompete_teaming_field": recompeteTeamingFieldSQL, 125 } { 126 lower := strings.ToLower(sql) 127 var sawPublic bool 128 for pt := range publicTables { 129 if strings.Contains(lower, pt) { 130 sawPublic = true 131 } 132 } 133 if !sawPublic { 134 t.Errorf("%s: must read a public market table", name) 135 } 136 } 137} 138 139// TestTeamingRatioGuardsDivideByZero pins the divide by zero guard: the team versus compete ratio is a numeric 140// over a numeric, and the denominator (the compete market count) is wrapped in NULLIF so a partner with no 141// compete market divides to a null ratio rather than a divide by zero error. A regression that dropped the 142// NULLIF would fail here. 143func TestTeamingRatioGuardsDivideByZero(t *testing.T) { 144 lower := strings.ToLower(partnerOrCompetitorRatioSQL) 145 if !strings.Contains(lower, "nullif(") { 146 t.Error("the team versus compete ratio must guard the divisor with NULLIF so a partner with no compete market divides safely") 147 } 148 // The ratio is a numeric over a numeric (the divide by zero safe decimal), never a float division. 149 if !strings.Contains(lower, ")::numeric, 0)") { 150 t.Error("the ratio divisor must be a numeric guarded with NULLIF(..., 0)") 151 } 152} 153 154// TestTeamingNoFloatTouchesADollarOrRatio is the decimal mandate, pinned statically across all three G2 155// intents: no ::float8, no ::float, no ::double precision, and no ::real cast may touch a dollar figure, a 156// concentration, or the team versus compete ratio. Every dollar and the ratio stay Postgres numeric end to 157// end and are scanned into shopspring/decimal in Go. A cast to a float type would silently lose the bit 158// stable precision the AEDT compliance asset requires. 159func TestTeamingNoFloatTouchesADollarOrRatio(t *testing.T) { 160 for name, sql := range map[string]string{ 161 "vendor_cooccurrence_field": vendorCooccurrenceFieldSQL, 162 "partner_or_competitor_ratio": partnerOrCompetitorRatioSQL, 163 "recompete_teaming_field": recompeteTeamingFieldSQL, 164 } { 165 lower := strings.ToLower(sql) 166 for _, floatCast := range []string{"::float8", "::float", "::double precision", "::real"} { 167 if strings.Contains(lower, floatCast) { 168 t.Errorf("%s: a float cast %q must never touch a dollar, a concentration, or a ratio (decimal mandate)", name, floatCast) 169 } 170 } 171 } 172} 173 174// TestTeamingEveryListOrderEndsWithAUniqueTiebreaker pins the byte stable mandate: every G2 intent that 175// returns a list ends its ORDER BY with a unique tiebreaker, so the same inputs yield byte identical rows. The 176// vendor co occurrence field orders by the segment dollars then the source table then the UEI (a total order 177// over the unioned rows), and the recompete teaming field orders by the period of performance end then the 178// opportunity id then the neighbor UEI (a total order over the rows). The partner ratio returns a single 179// summary row, a total order on its own, so it carries no ORDER BY. 180func TestTeamingEveryListOrderEndsWithAUniqueTiebreaker(t *testing.T) { 181 listCases := []struct { 182 name string 183 sql string 184 mustContain string 185 }{ 186 // The vendor co occurrence field unions the awards and the opportunity arms; the source_table plus the 187 // vendor_uei is the unique tiebreaker after the dollar concentration. 188 {"vendor_cooccurrence_field", vendorCooccurrenceFieldSQL, "source_table, vendor_uei"}, 189 // The recompete teaming field orders by the period of performance end then the opportunity id then the 190 // neighbor UEI, a total order over the opportunity by neighbor rows. 191 {"recompete_teaming_field", recompeteTeamingFieldSQL, "e.id, neighbor_uei"}, 192 } 193 for _, tc := range listCases { 194 lower := strings.ToLower(tc.sql) 195 idx := strings.LastIndex(lower, "order by") 196 if idx < 0 { 197 t.Errorf("%s: the list must be ordered for byte stability", tc.name) 198 continue 199 } 200 orderClause := lower[idx:] 201 if !strings.Contains(orderClause, strings.ToLower(tc.mustContain)) { 202 t.Errorf("%s: the ORDER BY must carry the unique tiebreaker %q, got %q", tc.name, tc.mustContain, orderClause) 203 } 204 } 205} 206 207// TestTeamingEdgesAreLabeledPrimeOfRecord pins the honesty mandate that every vendor or incumbent edge the G2 208// graph surfaces is the PRIME recipient of record, never the staffing subcontractor: the public award data 209// carries the prime recipient only, so labeling the edge prime-of-record is the honest statement of what the 210// data supports. A regression that dropped the label would fail here. 211func TestTeamingEdgesAreLabeledPrimeOfRecord(t *testing.T) { 212 for name, sql := range map[string]string{ 213 "vendor_cooccurrence_field": vendorCooccurrenceFieldSQL, 214 "partner_or_competitor_ratio": partnerOrCompetitorRatioSQL, 215 "recompete_teaming_field": recompeteTeamingFieldSQL, 216 } { 217 if !strings.Contains(strings.ToLower(sql), "prime-of-record") { 218 t.Errorf("%s: every vendor or incumbent edge must be labeled prime-of-record", name) 219 } 220 } 221 // The constant label is also the package primeOfRecordLabel; pin they agree so the honest label is one 222 // source of truth across the market graph. 223 if primeOfRecordLabel != "prime-of-record" { 224 t.Errorf("the prime of record label constant must be prime-of-record, got %q", primeOfRecordLabel) 225 } 226} 227 228// TestTeamingNullableTargetsAreDecimalPointers pins the G9 NULL discipline carried into G2: the nullable 229// numeric dollar figures (the co occurrence segment dollars, the team versus compete ratio, the neighbor 230// dollars) are scanned into *decimal.Decimal so a row with no award dollars or a partner with no compete 231// market scans cleanly rather than failing the scan. A live staging run will hit these NULLs, so the 232// discipline is load bearing. 233func TestTeamingNullableTargetsAreDecimalPointers(t *testing.T) { 234 co := CooccurrenceRow{} 235 if co.SegmentDollars != nil { 236 t.Error("the co occurrence segment dollars must be a nullable decimal pointer (null on an opportunity sourced edge)") 237 } 238 pr := PartnerRatioRow{} 239 if pr.TeamVsCompeteRatio != nil { 240 t.Error("the team versus compete ratio must be a nullable decimal pointer (null when the partner has no compete market)") 241 } 242 tf := TeamingFieldRow{} 243 if tf.NeighborDollars != nil { 244 t.Error("the neighbor dollars must be a nullable decimal pointer (null when the incumbent has no neighborhood)") 245 } 246} 247 248// TestTeamingIntentsAreGraphIntents proves the three G2 intents are classified as GRAPH intents (dispatched to 249// AnswerGraph, not AnswerTAG), so the graph evidence rendering and the graph route audit apply, and each is 250// also a real registered intent in the closed Registry. 251func TestTeamingIntentsAreGraphIntents(t *testing.T) { 252 for _, name := range []string{IntentVendorCooccurrenceField, IntentPartnerOrCompetitorRatio, IntentRecompeteTeamingField} { 253 if !IsGraphIntent(name) { 254 t.Errorf("%q must be a graph intent", name) 255 } 256 if _, ok := IntentByName(name); !ok { 257 t.Errorf("graph intent %q must be registered in the closed Registry", name) 258 } 259 } 260} 261 262// TestGraphClassifyRoutesTeamingQuestions proves the conservative NL router maps a free form G2 question that 263// clearly names a traversal AND carries the params to bind it unambiguously to the right intent with the right 264// args. The vendor co occurrence field needs BOTH a quoted agency and a bare NAICS; the partner ratio needs a 265// quoted UEI and a bare NAICS; the recompete teaming field needs a quoted agency. It never authors a param the 266// user did not delimit. 267func TestGraphClassifyRoutesTeamingQuestions(t *testing.T) { 268 cases := []struct { 269 name string 270 question string 271 intent string 272 args []any 273 }{ 274 { 275 name: "vendor co occurrence with quoted agency and bare naics", 276 question: `who teams up, the teaming field in "DEPT OF THE AIR FORCE" for 541512`, 277 intent: IntentVendorCooccurrenceField, 278 args: []any{"DEPT OF THE AIR FORCE", "541512"}, 279 }, 280 { 281 name: "partner or competitor ratio with quoted uei and bare naics", 282 question: `does partner "N3GDEB78RNF8" team or compete with us in 541330`, 283 intent: IntentPartnerOrCompetitorRatio, 284 args: []any{"N3GDEB78RNF8", "541330"}, 285 }, 286 { 287 name: "recompete teaming field with quoted agency and stated window", 288 question: `show the recompete teaming field for "DEPT OF DEFENSE" over the next 18 months`, 289 intent: IntentRecompeteTeamingField, 290 args: []any{"DEPT OF DEFENSE", 18}, 291 }, 292 { 293 name: "recompete teaming field with quoted agency and default window", 294 question: `who could team on the recompete for "GSA"`, 295 intent: IntentRecompeteTeamingField, 296 args: []any{"GSA", 0}, 297 }, 298 } 299 for _, tc := range cases { 300 t.Run(tc.name, func(t *testing.T) { 301 gr := graphClassify(tc.question) 302 if gr == nil { 303 t.Fatalf("graphClassify(%q) must route to a graph intent", tc.question) 304 } 305 if gr.intent != tc.intent { 306 t.Errorf("intent: got %q, want %q", gr.intent, tc.intent) 307 } 308 if len(gr.args) != len(tc.args) { 309 t.Fatalf("args length: got %d %v, want %d %v", len(gr.args), gr.args, len(tc.args), tc.args) 310 } 311 for i := range tc.args { 312 if gr.args[i] != tc.args[i] { 313 t.Errorf("arg %d: got %v, want %v", i, gr.args[i], tc.args[i]) 314 } 315 } 316 }) 317 } 318} 319 320// TestGraphClassifyTeamingFallsBackWhenParamsMissing is the conservatism test for the G2 routes: a teaming 321// question that clearly names a traversal but does NOT carry the params to bind it returns nil, so the caller 322// falls back to RAG rather than guessing an agency, a UEI, or a NAICS. The model never authors params; an 323// unbindable teaming question is a RAG question. 324func TestGraphClassifyTeamingFallsBackWhenParamsMissing(t *testing.T) { 325 fallback := []string{ 326 // A co occurrence question with a NAICS but no quoted agency: the segment key is incomplete. 327 "who teams up in the cloud market for 541512", 328 // A co occurrence question with a quoted agency but no NAICS: still incomplete. 329 `who appears together in "DEPT OF THE AIR FORCE"`, 330 // A partner ratio question with a NAICS but no quoted UEI: nothing to bind. 331 "does the partner team or compete with us in 541330", 332 // A partner ratio question with a quoted UEI but no NAICS: the core NAICS is missing. 333 `does partner "N3GDEB78RNF8" team or compete with us`, 334 // A recompete teaming question with no quoted agency. 335 "who could team on the recompete in general", 336 } 337 for _, q := range fallback { 338 if gr := graphClassify(q); gr != nil { 339 t.Errorf("graphClassify(%q) must fall back (nil) when params cannot be bound, got intent %q args %v", q, gr.intent, gr.args) 340 } 341 } 342} 343 344// TestGraphClassifyExistingCompetitorRouteUnchanged pins the Phase 0 route is byte unchanged: a bare competitor 345// or incumbent question with a quoted agency and a bare NAICS still routes to the existing G1 346// IntentSegmentCompetitorField, not a new G2 intent. The new G2 intents are selected only by their distinct 347// teaming keywords (co occur, teaming field, partner or competitor, recompete teaming), so the existing 348// competitor route is untouched. 349func TestGraphClassifyExistingCompetitorRouteUnchanged(t *testing.T) { 350 gr := graphClassify(`who is the competitor in "DEPT OF THE AIR FORCE" for 541512`) 351 if gr == nil { 352 t.Fatal("the existing G1 competitor question with a quoted agency and a NAICS must still route") 353 } 354 if gr.intent != IntentSegmentCompetitorField { 355 t.Errorf("the existing competitor question must route to the Phase 0 G1 intent, got %q", gr.intent) 356 } 357} 358