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

1package ai 2 3import ( 4 "strings" 5 "testing" 6) 7 8// TestGraphMarketIntentsAreRegistered proves the four G1 market traversals are in the closed Registry, so 9// ValidateRegistry asserts them at boot and ExecuteIntent can run them. A missing intent means the 10// registration regressed. 11func TestGraphMarketIntentsAreRegistered(t *testing.T) { 12 cases := map[string]int{ 13 IntentSegmentCompetitorField: 3, // agency, naics, lookback_years 14 IntentIncumbentOfRecord: 1, // opportunity_id 15 IntentRecompetePipeline: 2, // agency, window_months 16 IntentAgencyBuyingPattern: 2, // agency_prefix, naics 17 } 18 for name, wantParams := range cases { 19 it, ok := IntentByName(name) 20 if !ok { 21 t.Fatalf("intent %q must be registered in the closed Registry", name) 22 } 23 if len(it.Params) != wantParams { 24 t.Errorf("intent %q must bind exactly %d params, got %d", name, wantParams, len(it.Params)) 25 } 26 } 27} 28 29// TestGraphMarketIntentsPassTheReadOnlyGuard is the load bearing security assertion: each registered market 30// intent passes GuardReadOnlyQuery against the real ReadAllowlist. A query that referenced a non allowlisted 31// table, hid a mutation, or named an eeo marker would fail here, the same gate ValidateRegistry runs at boot 32// and ExecuteIntent re runs at execution time. 33func TestGraphMarketIntentsPassTheReadOnlyGuard(t *testing.T) { 34 for _, sql := range []string{ 35 segmentCompetitorFieldSQL, 36 incumbentOfRecordSQL, 37 recompetePipelineSQL, 38 agencyBuyingPatternSQL, 39 } { 40 if err := GuardReadOnlyQuery(sql, ReadAllowlist); err != nil { 41 t.Errorf("a registered market intent must pass the read only guard: %v", err) 42 } 43 } 44} 45 46// TestValidateRegistryWithMarketIntents proves the whole closed Registry, now carrying the four G1 intents 47// alongside the TAG and G3 intents, validates at boot. This is the assertion the api boot runs. 48func TestValidateRegistryWithMarketIntents(t *testing.T) { 49 if err := ValidateRegistry(); err != nil { 50 t.Fatalf("ValidateRegistry must pass with the four G1 market intents registered: %v", err) 51 } 52} 53 54// TestAwardsKeyOnlyOnAgencyAndNaics is the honesty mandate, pinned statically: usaspending_awards carries NO 55// psc, NO set_aside, and NO pop_state column, so neither the competitor field nor the incumbent walk may 56// select or join on those columns against the award table. The award arms key ONLY on the agency and NAICS 57// columns the table actually has. A regression that reached for a phantom award column would fail here. 58func TestAwardsKeyOnlyOnAgencyAndNaics(t *testing.T) { 59 // The two intents that read usaspending_awards. The competitor field aggregates awards; the incumbent 60 // walk joins an opportunity to its predecessor award. 61 awardIntents := map[string]string{ 62 "segment_competitor_field": segmentCompetitorFieldSQL, 63 "incumbent_of_record": incumbentOfRecordSQL, 64 } 65 for name, sql := range awardIntents { 66 lower := strings.ToLower(sql) 67 // The award join and filter keys: the only two columns usaspending_awards carries for the segment. 68 if !strings.Contains(lower, "awarding_agency") { 69 t.Errorf("%s: the award arm must key on awarding_agency", name) 70 } 71 if !strings.Contains(lower, "naics_code") { 72 t.Errorf("%s: the award arm must key on naics_code", name) 73 } 74 // The phantom columns the award table does NOT have. None may appear qualified to the award alias. 75 for _, phantom := range []string{"a.psc", "a.set_aside", "a.pop_state"} { 76 if strings.Contains(lower, phantom) { 77 t.Errorf("%s: usaspending_awards has no %s column; the award arm must not reference it", name, phantom) 78 } 79 } 80 } 81} 82 83// TestIncumbentEdgeLabeledPrimeOfRecord pins that every incumbent edge the graph surfaces carries the 84// constant prime-of-record label, never the staffing subcontractor: the public award data carries only the 85// prime recipient, so prime-of-record is the honest statement of what the data supports. The label is a SQL 86// constant column, so a row can never be unlabeled. 87func TestIncumbentEdgeLabeledPrimeOfRecord(t *testing.T) { 88 lower := strings.ToLower(incumbentOfRecordSQL) 89 if !strings.Contains(lower, "'prime-of-record'") { 90 t.Error("the incumbent walk must label every incumbent edge with the constant prime-of-record") 91 } 92 if primeOfRecordLabel != "prime-of-record" { 93 t.Errorf("the prime of record label constant drifted, got %q", primeOfRecordLabel) 94 } 95} 96 97// TestAgencyRollupUsesStringSplitNotRecursion pins that the agency hierarchy rollup uses the 98// full_parent_path string split and a GROUP BY, NOT a recursive CTE: the hierarchy is already a dotted 99// materialized path, so recursion would add a determinism risk and no value. The determinism mandate 100// explicitly prefers the string split where the data supports it. 101func TestAgencyRollupUsesStringSplitNotRecursion(t *testing.T) { 102 lower := strings.ToLower(agencyBuyingPatternSQL) 103 if !strings.Contains(lower, "split_part(s.full_parent_path") { 104 t.Error("the agency rollup must use a full_parent_path string split (split_part)") 105 } 106 if strings.Contains(lower, "with recursive") { 107 t.Error("the agency rollup must NOT use a recursive CTE; the dotted path makes recursion unnecessary") 108 } 109} 110 111// TestNoFloatTouchesADollarOrShare is the decimal mandate, pinned statically across all four market intents: 112// no ::float8, no ::float, no ::double precision, and no ::real cast may touch a dollar or a share figure. 113// Every dollar (award_amount, estimated_value) and every share stays Postgres numeric end to end and is 114// scanned into shopspring/decimal in Go. A cast to a float type would silently lose the bit stable precision 115// the AEDT compliance asset requires. 116func TestNoFloatTouchesADollarOrShare(t *testing.T) { 117 intents := map[string]string{ 118 "segment_competitor_field": segmentCompetitorFieldSQL, 119 "incumbent_of_record": incumbentOfRecordSQL, 120 "recompete_pipeline": recompetePipelineSQL, 121 "agency_buying_pattern": agencyBuyingPatternSQL, 122 } 123 for name, sql := range intents { 124 lower := strings.ToLower(sql) 125 for _, floatCast := range []string{"::float8", "::float", "::double precision", "::real"} { 126 if strings.Contains(lower, floatCast) { 127 t.Errorf("%s: a float cast %q must never touch a dollar or share figure (decimal mandate)", name, floatCast) 128 } 129 } 130 // The dollar and share math is positively numeric: the weighted dollars and the share carry the 131 // ::numeric type, so the cast is to the exact type, never a float. 132 if name == "segment_competitor_field" { 133 if !strings.Contains(lower, "::numeric") { 134 t.Errorf("%s: the weighted dollars and share must be cast to numeric, the exact decimal type", name) 135 } 136 } 137 } 138} 139 140// TestEveryListOrderEndsWithAUniqueTiebreaker pins the byte stable mandate: every market intent that returns 141// a list ends its ORDER BY with a unique id tiebreaker (a recipient UEI, an award generated_internal_id, a 142// record id, or the full grouped key), so the same inputs yield byte identical rows. 143func TestEveryListOrderEndsWithAUniqueTiebreaker(t *testing.T) { 144 cases := []struct { 145 name string 146 sql string 147 mustContain string // a fragment proving the ORDER BY ends with the unique tiebreaker 148 }{ 149 // The competitor field is grouped per recipient; the UEI is the unique tiebreaker. 150 {"segment_competitor_field", segmentCompetitorFieldSQL, "w.recipient_uei"}, 151 // The incumbent walk picks the most recent award; the generated_internal_id is the unique tiebreaker. 152 {"incumbent_of_record", incumbentOfRecordSQL, "a.generated_internal_id"}, 153 // The pipeline orders by the end date then the record id, a total order. 154 {"recompete_pipeline", recompetePipelineSQL, "record_id"}, 155 // The buying pattern groups; the grouped keys are the total order. 156 {"agency_buying_pattern", agencyBuyingPatternSQL, "b.value_band"}, 157 } 158 for _, tc := range cases { 159 lower := strings.ToLower(tc.sql) 160 idx := strings.LastIndex(lower, "order by") 161 if idx < 0 { 162 t.Errorf("%s: the list must be ordered for byte stability", tc.name) 163 continue 164 } 165 orderClause := lower[idx:] 166 if !strings.Contains(orderClause, strings.ToLower(tc.mustContain)) { 167 t.Errorf("%s: the ORDER BY must carry the unique tiebreaker %q, got %q", tc.name, tc.mustContain, orderClause) 168 } 169 } 170} 171 172// TestMarketIntentsAreNotRecursiveWhereAvoidable confirms the market intents are aggregates and joins, not 173// recursive walks: none of the four uses WITH RECURSIVE. The market questions are answered by GROUP BY 174// rollups and a string split, exactly as the determinism mandate prefers over recursion. 175func TestMarketIntentsAreNotRecursiveWhereAvoidable(t *testing.T) { 176 for name, sql := range map[string]string{ 177 "segment_competitor_field": segmentCompetitorFieldSQL, 178 "incumbent_of_record": incumbentOfRecordSQL, 179 "recompete_pipeline": recompetePipelineSQL, 180 "agency_buying_pattern": agencyBuyingPatternSQL, 181 } { 182 if strings.Contains(strings.ToLower(sql), "with recursive") { 183 t.Errorf("%s: a market aggregate must not use a recursive CTE; the data already carries the keys", name) 184 } 185 } 186} 187 188// TestClampMarketBounds proves the window and lookback are always normalized into the bounded range, so no 189// caller bound value (zero, negative, or oversized) can widen a bounded scan into an unbounded one. 190func TestClampMarketBounds(t *testing.T) { 191 windowCases := map[int]int{ 192 0: DefaultRecompeteWindowMonths, 193 -5: DefaultRecompeteWindowMonths, 194 12: 12, 195 24: 24, 196 60: maxRecompeteWindowMonths, 197 120: maxRecompeteWindowMonths, 198 } 199 for in, want := range windowCases { 200 if got := ClampRecompeteWindowMonths(in); got != want { 201 t.Errorf("ClampRecompeteWindowMonths(%d) = %d, want %d", in, got, want) 202 } 203 } 204 lookbackCases := map[int]int{ 205 0: DefaultCompetitorLookbackYears, 206 -2: DefaultCompetitorLookbackYears, 207 5: 5, 208 15: maxCompetitorLookbackYears, 209 40: maxCompetitorLookbackYears, 210 } 211 for in, want := range lookbackCases { 212 if got := ClampCompetitorLookbackYears(in); got != want { 213 t.Errorf("ClampCompetitorLookbackYears(%d) = %d, want %d", in, got, want) 214 } 215 } 216} 217