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

1package ai 2 3import ( 4 "strings" 5 "testing" 6) 7 8// TestGraphLifecycleIntentsAreRegistered proves the three G9 lifecycle traversals are in the closed Registry, 9// so ValidateRegistry asserts them at boot and ExecuteIntent can run them. A missing intent means the 10// registration regressed. 11func TestGraphLifecycleIntentsAreRegistered(t *testing.T) { 12 cases := map[string]int{ 13 IntentProcurementSuccession: 1, // opportunity_id 14 IntentRecompeteClock: 2, // agency, window_months 15 IntentForecastRunway: 1, // 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// TestGraphLifecycleWindowParamsAreClamped pins that the forward window param on the recompete clock and the 29// forecast runway carries the bounded ParamInt Min 1 Max 60, so the structured path clamps a caller bound 30// window into the bounded range and an oversized or non positive value can never widen a bounded scan. 31func TestGraphLifecycleWindowParamsAreClamped(t *testing.T) { 32 for _, name := range []string{IntentRecompeteClock, IntentForecastRunway} { 33 it, ok := IntentByName(name) 34 if !ok { 35 t.Fatalf("intent %q must be registered", name) 36 } 37 var sawWindow bool 38 for _, p := range it.Params { 39 if p.Name == "window_months" { 40 sawWindow = true 41 if p.Kind != ParamInt { 42 t.Errorf("%s: window_months must be a ParamInt, got %q", name, p.Kind) 43 } 44 if p.Min != 1 || p.Max != 60 { 45 t.Errorf("%s: window_months must clamp to Min 1 Max 60, got Min %d Max %d", name, p.Min, p.Max) 46 } 47 } 48 } 49 if !sawWindow { 50 t.Errorf("%s: must carry a window_months param", name) 51 } 52 } 53} 54 55// TestGraphLifecycleIntentsPassTheReadOnlyGuard is the load bearing security assertion: each registered 56// lifecycle intent passes GuardReadOnlyQuery against the real ReadAllowlist. A query that referenced a non 57// allowlisted table, hid a mutation, or named an eeo marker would fail here, the same gate ValidateRegistry 58// runs at boot and ExecuteIntent re runs at execution time. 59func TestGraphLifecycleIntentsPassTheReadOnlyGuard(t *testing.T) { 60 for _, sql := range []string{ 61 procurementSuccessionSQL, 62 recompeteClockSQL, 63 forecastRunwaySQL, 64 } { 65 if err := GuardReadOnlyQuery(sql, ReadAllowlist); err != nil { 66 t.Errorf("a registered lifecycle intent must pass the read only guard: %v", err) 67 } 68 } 69} 70 71// TestValidateRegistryWithLifecycleIntents proves the whole closed Registry, now carrying the three G9 72// intents alongside the TAG, G3, and G1 intents, validates at boot. This is the assertion the api boot runs. 73func TestValidateRegistryWithLifecycleIntents(t *testing.T) { 74 if err := ValidateRegistry(); err != nil { 75 t.Fatalf("ValidateRegistry must pass with the three G9 lifecycle intents registered: %v", err) 76 } 77} 78 79// TestLifecycleAwardsArmKeysOnlyOnAgencyAndNaics is the honesty mandate, pinned statically: usaspending_awards 80// carries NO psc, NO set_aside, and NO pop_state column, so the only lifecycle arm that reads the award table 81// (the recompete clock award arm) may not select or join on those columns against the award alias. The award 82// arm keys ONLY on awarding_agency and the columns the table actually has. A regression that reached for a 83// phantom award column would fail here. 84func TestLifecycleAwardsArmKeysOnlyOnAgencyAndNaics(t *testing.T) { 85 // The recompete clock is the only lifecycle intent that reads usaspending_awards. The succession and the 86 // runway live entirely in opportunity_records and federal_mission_tags, never the award table. 87 lower := strings.ToLower(recompeteClockSQL) 88 if !strings.Contains(lower, "awarding_agency") { 89 t.Error("recompete_clock: the award arm must key on awarding_agency") 90 } 91 // The phantom columns the award table does NOT have. None may appear qualified to the award alias a. 92 for _, phantom := range []string{"a.psc", "a.set_aside", "a.pop_state"} { 93 if strings.Contains(lower, phantom) { 94 t.Errorf("recompete_clock: usaspending_awards has no %s column; the award arm must not reference it", phantom) 95 } 96 } 97 // The succession and the runway must NOT read usaspending_awards at all (they are opportunity_records and 98 // mission tag sourced), so no phantom award column risk exists on those arms by construction. 99 for name, sql := range map[string]string{ 100 "procurement_succession": procurementSuccessionSQL, 101 "forecast_runway": forecastRunwaySQL, 102 } { 103 if strings.Contains(strings.ToLower(sql), "usaspending_awards") { 104 t.Errorf("%s: must live in opportunity_records, not read the award table (no phantom column surface)", name) 105 } 106 } 107} 108 109// TestSuccessionTupleIsOpportunityRecordsSourced pins that the procurement succession keys on the FULL 110// (agency, naics, psc, pop_state, set_aside) segment tuple, which only opportunity_records carries: the 111// dedupe_key succession walks within that segment, so the finer slice the question needs is honestly sourced 112// from the one table that supports it. 113func TestSuccessionTupleIsOpportunityRecordsSourced(t *testing.T) { 114 lower := strings.ToLower(procurementSuccessionSQL) 115 for _, key := range []string{"a.agency = an.agency", "a.naics = an.naics", "a.psc = an.psc", "a.pop_state = an.pop_state", "a.set_aside = an.set_aside"} { 116 if !strings.Contains(lower, key) { 117 t.Errorf("the succession must key on the full segment tuple; missing %q", key) 118 } 119 } 120 if !strings.Contains(lower, "a.dedupe_key = an.dedupe_key") { 121 t.Error("the succession must link the phases on the shared dedupe_key") 122 } 123} 124 125// TestLifecycleIncumbentEdgeLabeledPrimeOfRecord pins that every incumbent edge the lifecycle graph surfaces 126// carries the constant prime-of-record label, never the staffing subcontractor: the public data carries only 127// the prime recipient or the catalog recorded incumbent, so prime-of-record is the honest statement of what 128// the data supports. The label is a SQL constant column, so a row can never be unlabeled. 129func TestLifecycleIncumbentEdgeLabeledPrimeOfRecord(t *testing.T) { 130 for name, sql := range map[string]string{ 131 "procurement_succession": procurementSuccessionSQL, 132 "recompete_clock": recompeteClockSQL, 133 } { 134 if !strings.Contains(strings.ToLower(sql), "'prime-of-record'") { 135 t.Errorf("%s: must label every incumbent edge with the constant prime-of-record", name) 136 } 137 } 138 if primeOfRecordLabel != "prime-of-record" { 139 t.Errorf("the prime of record label constant drifted, got %q", primeOfRecordLabel) 140 } 141} 142 143// TestSuccessionPrefersFixedJoinsNotRecursion confirms the procurement succession is a FIXED set of LEFT JOINs 144// (forecast to solicitation to predecessor award is at most three phases), NOT a recursive CTE: the dedupe_key 145// already links the phases, so recursion would add a determinism risk and no value. The determinism mandate 146// explicitly prefers fixed joins where the data carries the keys. The recompete clock and the forecast runway 147// are likewise plain reads, not recursion. 148func TestSuccessionPrefersFixedJoinsNotRecursion(t *testing.T) { 149 for name, sql := range map[string]string{ 150 "procurement_succession": procurementSuccessionSQL, 151 "recompete_clock": recompeteClockSQL, 152 "forecast_runway": forecastRunwaySQL, 153 } { 154 if strings.Contains(strings.ToLower(sql), "with recursive") { 155 t.Errorf("%s: a lifecycle read must not use a recursive CTE; the data already carries the keys", name) 156 } 157 } 158 // The succession positively uses the fixed LEFT JOINs over the predecessor and the forecast phases. 159 lower := strings.ToLower(procurementSuccessionSQL) 160 if !strings.Contains(lower, "left join predecessor") || !strings.Contains(lower, "left join forecast") { 161 t.Error("the succession must use the fixed LEFT JOINs to the predecessor award and the forecast phases") 162 } 163} 164 165// TestLifecycleNoFloatTouchesADollar is the decimal mandate, pinned statically across all three lifecycle 166// intents: no ::float8, no ::float, no ::double precision, and no ::real cast may touch a dollar figure. Every 167// dollar (estimated_value, award_amount) stays Postgres numeric end to end and is scanned into 168// shopspring/decimal in Go. A cast to a float type would silently lose the bit stable precision the AEDT 169// compliance asset requires. 170func TestLifecycleNoFloatTouchesADollar(t *testing.T) { 171 intents := map[string]string{ 172 "procurement_succession": procurementSuccessionSQL, 173 "recompete_clock": recompeteClockSQL, 174 "forecast_runway": forecastRunwaySQL, 175 } 176 for name, sql := range intents { 177 lower := strings.ToLower(sql) 178 for _, floatCast := range []string{"::float8", "::float", "::double precision", "::real"} { 179 if strings.Contains(lower, floatCast) { 180 t.Errorf("%s: a float cast %q must never touch a dollar figure (decimal mandate)", name, floatCast) 181 } 182 } 183 } 184} 185 186// TestLifecycleEveryListOrderEndsWithAUniqueTiebreaker pins the byte stable mandate: every lifecycle intent 187// that returns a list ends its ORDER BY with a unique id tiebreaker (a record id), so the same inputs yield 188// byte identical rows. The succession returns a single anchored row, so it carries the unique tiebreaker on 189// its internal predecessor and forecast picks instead, also pinned here. 190func TestLifecycleEveryListOrderEndsWithAUniqueTiebreaker(t *testing.T) { 191 listCases := []struct { 192 name string 193 sql string 194 mustContain string 195 }{ 196 // The recompete clock orders by the end date then the record id, a total order. 197 {"recompete_clock", recompeteClockSQL, "record_id"}, 198 // The forecast runway orders by the estimated award date then the opportunity id, a total order. 199 {"forecast_runway", forecastRunwaySQL, "o.id"}, 200 } 201 for _, tc := range listCases { 202 lower := strings.ToLower(tc.sql) 203 idx := strings.LastIndex(lower, "order by") 204 if idx < 0 { 205 t.Errorf("%s: the list must be ordered for byte stability", tc.name) 206 continue 207 } 208 orderClause := lower[idx:] 209 if !strings.Contains(orderClause, strings.ToLower(tc.mustContain)) { 210 t.Errorf("%s: the ORDER BY must carry the unique tiebreaker %q, got %q", tc.name, tc.mustContain, orderClause) 211 } 212 } 213 // The succession's internal single row picks are each totally ordered by an id tiebreaker, so the LIMIT 1 214 // pick is deterministic for the predecessor and the forecast phases. 215 lower := strings.ToLower(procurementSuccessionSQL) 216 if !strings.Contains(lower, "order by a.award_date desc nulls last, a.id") { 217 t.Error("the succession predecessor pick must be totally ordered by award_date then the id tiebreaker") 218 } 219 if !strings.Contains(lower, "order by f.estimated_award_date desc nulls last, f.id") { 220 t.Error("the succession forecast pick must be totally ordered by estimated_award_date then the id tiebreaker") 221 } 222} 223 224// TestLifecycleIntentsAreGraphIntents proves the three G9 intents are classified as GRAPH intents (dispatched 225// to AnswerGraph, not AnswerTAG), so the graph evidence rendering and the graph route audit apply, and each is 226// also a real registered intent in the closed Registry. 227func TestLifecycleIntentsAreGraphIntents(t *testing.T) { 228 for _, name := range []string{IntentProcurementSuccession, IntentRecompeteClock, IntentForecastRunway} { 229 if !IsGraphIntent(name) { 230 t.Errorf("%q must be a graph intent", name) 231 } 232 if _, ok := IntentByName(name); !ok { 233 t.Errorf("graph intent %q must be registered in the closed Registry", name) 234 } 235 } 236} 237