Janady13/missionmatch / internal/integration/graph_market_integration_test.go

1//go:build integration 2 3package integration 4 5import ( 6 "context" 7 "encoding/json" 8 "testing" 9 "time" 10 11 "github.com/google/uuid" 12 "github.com/jackc/pgx/v5/pgtype" 13 "github.com/shopspring/decimal" 14 15 "github.com/missionworkforce/missionmatch/internal/modules/ai" 16 "github.com/missionworkforce/missionmatch/internal/platform/database/dbgen" 17) 18 19// seedMarketAward inserts one usaspending_awards row as the migrator (the global award catalog the app role 20// may only read), so the G1 market traversals have real award structure to aggregate. It keys only on the 21// columns usaspending_awards actually carries (awarding_agency, naics_code, recipient, award_amount, the 22// period of performance), the honest segment key the competitor field and incumbent walk use. 23func seedMarketAward(t *testing.T, genID, awardPIID, agency, naics, recipientUEI, recipientName, amount string, popEnd time.Time, isGalapagos bool) { 24 t.Helper() 25 if _, err := migrator.Exec(context.Background(), 26 `INSERT INTO usaspending_awards 27 (generated_internal_id, award_id, recipient_uei, recipient_name, awarding_agency, naics_code, 28 award_amount, pop_end_date, is_galapagos, raw) 29 VALUES ($1, $2, $3, $4, $5, $6, $7::numeric, $8, $9, '{}'::jsonb) 30 ON CONFLICT (generated_internal_id) DO NOTHING`, 31 genID, awardPIID, recipientUEI, recipientName, agency, naics, amount, popEnd, isGalapagos); err != nil { 32 t.Fatalf("seed market award %s: %v", genID, err) 33 } 34} 35 36// TestG1SegmentCompetitorField is the live proof of the recency weighted competitor field against real 37// Postgres. It seeds a (agency, naics) segment with a dominant recipient and two smaller ones, plus the 38// tenant's own past performance, then proves: the field comes back ordered share descending, the shares are 39// exact decimals (never float64) that the dominant recipient leads, the tenant's own row is flagged 40// is_galapagos, the contributing award count is the cited evidence, and the result is byte stable on a re 41// run. The segment keys ONLY on (agency, naics), the only keys usaspending_awards carries. 42func TestG1SegmentCompetitorField(t *testing.T) { 43 org := seedOrg(t) 44 run := uuid.NewString()[:8] 45 agency := "DEPT OF THE AIR FORCE " + run // unique per run so the segment is isolated 46 naics := "541512" 47 recent := time.Now().UTC().AddDate(0, -3, 0) // inside the lookback window 48 49 // A dominant incumbent, two challengers, and the tenant's own award, all in the same (agency, naics). 50 seedMarketAward(t, "G1-CF-"+run+"-1", "PIID-1", agency, naics, "UEIDOMINANT01", "Dominant Defense LLC", "8000000.00", recent, false) 51 seedMarketAward(t, "G1-CF-"+run+"-2", "PIID-2", agency, naics, "UEICHALLENG02", "Challenger Two LLC", "1500000.00", recent, false) 52 seedMarketAward(t, "G1-CF-"+run+"-3", "PIID-3", agency, naics, "UEICHALLENG03", "Challenger Three LLC", "500000.00", recent, false) 53 seedMarketAward(t, "G1-CF-"+run+"-4", "PIID-4", agency, naics, "UEIGALAPAGOS4", "Galapagos Federal", "1000000.00", recent, true) 54 55 rows, err := ai.SegmentCompetitorField(ctxOrg(org), appDB, agency, naics, ai.DefaultCompetitorLookbackYears) 56 if err != nil { 57 t.Fatalf("segment competitor field: %v", err) 58 } 59 if len(rows) != 4 { 60 t.Fatalf("the competitor field must return the four distinct recipients in the segment, got %d", len(rows)) 61 } 62 63 // Ordered share descending: the dominant recipient leads, and every share is a decimal in 0 to 1. 64 if rows[0].RecipientUEI != "UEIDOMINANT01" { 65 t.Errorf("the dominant recipient must lead the field, got %q", rows[0].RecipientUEI) 66 } 67 prev := decimal.NewFromInt(2) // larger than any valid share 68 var total decimal.Decimal 69 for _, r := range rows { 70 if r.DollarShare.GreaterThan(prev) { 71 t.Errorf("the field must be ordered share descending; %s share %s exceeds the previous %s", r.RecipientUEI, r.DollarShare, prev) 72 } 73 prev = r.DollarShare 74 if r.DollarShare.LessThan(decimal.Zero) || r.DollarShare.GreaterThan(decimal.NewFromInt(1)) { 75 t.Errorf("a dollar share must be a decimal in 0 to 1, got %s for %s", r.DollarShare, r.RecipientUEI) 76 } 77 if r.AwardCount < 1 { 78 t.Errorf("the contributing award count (the evidence) must be at least 1, got %d for %s", r.AwardCount, r.RecipientUEI) 79 } 80 total = total.Add(r.DollarShare) 81 } 82 // The shares sum to 1 within numeric rounding: each share is dollars_i divided by the total, rounded to 83 // the numeric scale, so the sum of the rounded fractions can differ from 1 by a tiny residual (here on the 84 // order of 1e-20). That is mathematically unavoidable for divided decimals and harmless for a ranking and 85 // display figure; the decimal mandate is satisfied because no float64 touches the computation. Assert the 86 // sum is within a tight epsilon of 1, not bit exact. 87 if total.Sub(decimal.NewFromInt(1)).Abs().GreaterThan(decimal.RequireFromString("0.0000001")) { 88 t.Errorf("the dollar shares must sum to 1 within a tight epsilon in decimal, got %s", total) 89 } 90 91 // The tenant's own past performance is flagged is_galapagos so the capture team sees where it stands. 92 var sawGalapagos bool 93 for _, r := range rows { 94 if r.RecipientUEI == "UEIGALAPAGOS4" { 95 sawGalapagos = true 96 if !r.IsGalapagos { 97 t.Error("the tenant's own award row must be labeled is_galapagos") 98 } 99 } 100 } 101 if !sawGalapagos { 102 t.Error("the competitor field must include the tenant's own past performance row") 103 } 104 105 // Byte stable: the same input yields byte identical rows on a re run (the determinism mandate). The 106 // ORDER BY with the recipient_uei tiebreaker guarantees a single stable order. 107 again, err := ai.SegmentCompetitorField(ctxOrg(org), appDB, agency, naics, ai.DefaultCompetitorLookbackYears) 108 if err != nil { 109 t.Fatalf("segment competitor field re run: %v", err) 110 } 111 first, _ := json.Marshal(rows) 112 second, _ := json.Marshal(again) 113 if string(first) != string(second) { 114 t.Errorf("the competitor field must be byte stable on a re run.\nfirst: %s\nsecond: %s", first, second) 115 } 116} 117 118// TestG1IncumbentOfRecord proves the incumbent walk returns the predecessor award for an opportunity matched 119// on (agency, naics) and the cross source dedupe key, with the prime recipient explicitly labeled 120// prime-of-record (never the staffing subcontractor, the only incumbent the public award data supports). 121func TestG1IncumbentOfRecord(t *testing.T) { 122 org := seedOrg(t) 123 run := uuid.NewString()[:8] 124 agency := "DEPT OF DEFENSE " + run 125 naics := "541330" 126 dedupe := "INCUMBENT-DEDUPE-" + run 127 128 // The predecessor award. The opportunity's dedupe_key matches the award's PIID, the cross source link. 129 seedMarketAward(t, "G1-INC-"+run, dedupe, agency, naics, "UEIINCUMBENT9", "Incumbent Prime LLC", "5000000.00", 130 time.Now().UTC().AddDate(0, 6, 0), false) 131 132 // The recompete opportunity that walks back to its predecessor award. 133 srcID := "G1-OPP-" + run 134 if err := dbgen.New(migrator).UpsertOpportunityRecord(context.Background(), dbgen.UpsertOpportunityRecordParams{ 135 SourceName: "SAM.gov", SourceRecordID: srcID, DedupeKey: dedupe, RecordKind: "active_solicitation", 136 Title: "Engineering services recompete", Agency: agency, Naics: naics, 137 FetchedAt: time.Now().UTC(), 138 }); err != nil { 139 t.Fatalf("seed opportunity: %v", err) 140 } 141 142 // Resolve the opportunity id (gen_random_uuid primary key) so we can walk from it. 143 var oppID string 144 if err := migrator.QueryRow(context.Background(), 145 `SELECT id::text FROM opportunity_records WHERE source_name = 'SAM.gov' AND source_record_id = $1`, srcID).Scan(&oppID); err != nil { 146 t.Fatalf("resolve opportunity id: %v", err) 147 } 148 149 edges, err := ai.IncumbentOfRecord(ctxOrg(org), appDB, oppID) 150 if err != nil { 151 t.Fatalf("incumbent of record: %v", err) 152 } 153 if len(edges) == 0 { 154 t.Fatal("the incumbent walk must return the predecessor award matched on agency, naics, and the dedupe key") 155 } 156 e := edges[0] 157 if e.IncumbentUEI != "UEIINCUMBENT9" { 158 t.Errorf("the incumbent must be the prime recipient of the matched award, got %q", e.IncumbentUEI) 159 } 160 if e.IncumbentRole != "prime-of-record" { 161 t.Errorf("the incumbent edge must be labeled prime-of-record, got %q", e.IncumbentRole) 162 } 163 if e.AwardID != "G1-INC-"+run { 164 t.Errorf("the cited evidence must be the matched award, got %q", e.AwardID) 165 } 166 if e.AwardAmount == nil || !e.AwardAmount.Equal(decimal.RequireFromString("5000000.00")) { 167 t.Errorf("the matched award amount must be the decimal 5000000.00, got %v", e.AwardAmount) 168 } 169} 170 171// TestG1RecompetePipeline proves the recompete pipeline returns the opportunities and awards whose period of 172// performance end falls inside the forward window, ordered by that end date with a record id tiebreaker, each 173// row carrying its source so an award is never conflated with an opportunity. It is byte stable on a re run. 174func TestG1RecompetePipeline(t *testing.T) { 175 org := seedOrg(t) 176 run := uuid.NewString()[:8] 177 agency := "DEPT OF THE NAVY " + run 178 179 insideWindow := time.Now().UTC().AddDate(0, 6, 0) // 6 months out, inside the 24 month window 180 outsideWindow := time.Now().UTC().AddDate(5, 0, 0) // 5 years out, past the window 181 182 // An award ending inside the window (a takeaway target) and one ending far outside it (must not appear). 183 seedMarketAward(t, "G1-RC-IN-"+run, "PIID-IN", agency, "541512", "UEIAWARDIN001", "Award In Window LLC", "3000000.00", insideWindow, false) 184 seedMarketAward(t, "G1-RC-OUT-"+run, "PIID-OUT", agency, "541512", "UEIAWARDOUT01", "Award Out Window LLC", "3000000.00", outsideWindow, false) 185 186 // An opportunity ending inside the window. 187 oppSrc := "G1-RC-OPP-" + run 188 estVal := decimal.RequireFromString("4250000.00") 189 if err := dbgen.New(migrator).UpsertOpportunityRecord(context.Background(), dbgen.UpsertOpportunityRecordParams{ 190 SourceName: "SAM.gov", SourceRecordID: oppSrc, RecordKind: "active_solicitation", 191 Title: "Logistics recompete", Agency: agency, Naics: "541512", 192 IncumbentUei: "UEIOPPINCUMB1", EstimatedValue: &estVal, ValueSource: "operator", 193 PopEndDate: pgtype.Date{Time: insideWindow, Valid: true}, 194 FetchedAt: time.Now().UTC(), 195 }); err != nil { 196 t.Fatalf("seed pipeline opportunity: %v", err) 197 } 198 199 rows, err := ai.RecompetePipeline(ctxOrg(org), appDB, agency, ai.DefaultRecompeteWindowMonths) 200 if err != nil { 201 t.Fatalf("recompete pipeline: %v", err) 202 } 203 if len(rows) != 2 { 204 t.Fatalf("the pipeline must return exactly the award and the opportunity inside the window, got %d", len(rows)) 205 } 206 207 var sawAward, sawOpp bool 208 prev := time.Time{} 209 for _, r := range rows { 210 // Ordered by pop_end_date ascending: each end date is at or after the previous, a total order. 211 end, perr := time.Parse("2006-01-02", r.PopEndDate) 212 if perr != nil { 213 t.Fatalf("the pop end date must be a stable ISO date, got %q", r.PopEndDate) 214 } 215 if end.Before(prev) { 216 t.Errorf("the pipeline must be ordered by pop end date ascending; %s precedes the previous %s", end, prev) 217 } 218 prev = end 219 switch r.SourceTable { 220 case "usaspending_awards": 221 sawAward = true 222 if r.RecordID != "G1-RC-IN-"+run { 223 t.Errorf("only the in window award may appear, got %q", r.RecordID) 224 } 225 case "opportunity_records": 226 sawOpp = true 227 if r.Dollars == nil || !r.Dollars.Equal(decimal.RequireFromString("4250000.00")) { 228 t.Errorf("the opportunity dollars must be the decimal 4250000.00, got %v", r.Dollars) 229 } 230 default: 231 t.Errorf("a pipeline row must carry a known source table, got %q", r.SourceTable) 232 } 233 } 234 if !sawAward || !sawOpp { 235 t.Errorf("the pipeline must include both the in window award and the in window opportunity (award %v, opp %v)", sawAward, sawOpp) 236 } 237 238 // Byte stable on a re run. 239 again, err := ai.RecompetePipeline(ctxOrg(org), appDB, agency, ai.DefaultRecompeteWindowMonths) 240 if err != nil { 241 t.Fatalf("recompete pipeline re run: %v", err) 242 } 243 first, _ := json.Marshal(rows) 244 second, _ := json.Marshal(again) 245 if string(first) != string(second) { 246 t.Errorf("the recompete pipeline must be byte stable on a re run.\nfirst: %s\nsecond: %s", first, second) 247 } 248} 249