Janady13/missionmatch / internal/integration/graph_teaming_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// seedTeamingOpportunity inserts one expiring opportunity_records row carrying an incumbent UEI and a 20// pop_end_date inside the forward window, the recompete teaming surface, as the migrator (the global public 21// catalog the app role may only read). It is the recompete clock side the G2 teaming field reads; the 22// incumbent neighborhood is resolved over the public awards in the same NAICS. 23func seedTeamingOpportunity(t *testing.T, srcID, agency, naics, incumbentUEI, incumbentName string, popEnd time.Time) { 24 t.Helper() 25 if err := dbgen.New(migrator).UpsertOpportunityRecord(context.Background(), dbgen.UpsertOpportunityRecordParams{ 26 SourceName: "SAM.gov", SourceRecordID: srcID, RecordKind: "active_solicitation", 27 Title: "Recompete " + srcID, Agency: agency, Naics: naics, 28 IncumbentUei: incumbentUEI, IncumbentName: incumbentName, 29 PopEndDate: pgtype.Date{Time: popEnd, Valid: true}, 30 FetchedAt: time.Now().UTC(), 31 }); err != nil { 32 t.Fatalf("seed teaming opportunity %s: %v", srcID, err) 33 } 34} 35 36// TestG2VendorCooccurrenceField is the live proof of the co occurrence field against real Postgres. It seeds a 37// (agency, naics) segment with two co occurring recipient UEIs plus the tenant's own is_galapagos award, then 38// proves the field returns the co occurring set ordered by the dollar concentration with a UEI tiebreaker, 39// each edge labeled prime-of-record and carrying its source, the tenant's own row flagged is_galapagos, the 40// segment dollars exact decimals, and byte stable on a re run. The awards arm keys ONLY on (agency, naics). 41func TestG2VendorCooccurrenceField(t *testing.T) { 42 org := seedOrg(t) 43 run := uuid.NewString()[:8] 44 agency := "DEPT OF THE AIR FORCE " + run // unique per run so the segment is isolated 45 naics := "541512" 46 recent := time.Now().UTC().AddDate(0, -3, 0) 47 48 // Two co occurring recipients (a dominant and a challenger) plus the tenant's own past performance, all in 49 // the same (agency, naics) segment. 50 seedMarketAward(t, "G2-CO-"+run+"-1", "PIID-1", agency, naics, "UEIDOMINANT01", "Dominant Defense LLC", "8000000.00", recent, false) 51 seedMarketAward(t, "G2-CO-"+run+"-2", "PIID-2", agency, naics, "UEICHALLENG02", "Challenger Two LLC", "2000000.00", recent, false) 52 seedMarketAward(t, "G2-CO-"+run+"-3", "PIID-3", agency, naics, "UEIGALAPAGOS3", "Galapagos Federal", "1000000.00", recent, true) 53 54 rows, err := ai.VendorCooccurrenceField(ctxOrg(org), appDB, agency, naics) 55 if err != nil { 56 t.Fatalf("vendor co occurrence field: %v", err) 57 } 58 if len(rows) < 3 { 59 t.Fatalf("the field must return the three co occurring recipients, got %d", len(rows)) 60 } 61 62 // The awards arm leads ordered by the dollar concentration descending; the dominant recipient is first. 63 if rows[0].VendorUEI != "UEIDOMINANT01" { 64 t.Errorf("the dominant recipient must lead the co occurrence field, got %q", rows[0].VendorUEI) 65 } 66 67 var sawGalapagos bool 68 for _, r := range rows { 69 if r.VendorUEI == "" { 70 t.Error("a co occurring vendor must carry an honest UEI, never the empty string") 71 } 72 if r.VendorRole != "prime-of-record" { 73 t.Errorf("every vendor edge must be labeled prime-of-record, got %q for %s", r.VendorRole, r.VendorUEI) 74 } 75 if r.SourceTable == "" { 76 t.Errorf("every edge must carry its source table, got empty for %s", r.VendorUEI) 77 } 78 if r.SourceTable == "usaspending_awards" && (r.SegmentDollars == nil || r.SegmentDollars.LessThanOrEqual(decimal.Zero)) { 79 t.Errorf("an award sourced edge must carry positive segment dollars as a decimal, got %v for %s", r.SegmentDollars, r.VendorUEI) 80 } 81 if r.VendorUEI == "UEIGALAPAGOS3" && r.SourceTable == "usaspending_awards" { 82 sawGalapagos = true 83 if !r.IsGalapagos { 84 t.Error("the tenant's own past performance row must be labeled is_galapagos") 85 } 86 } 87 } 88 if !sawGalapagos { 89 t.Error("the co occurrence field must include the tenant's own past performance award row") 90 } 91 92 again, err := ai.VendorCooccurrenceField(ctxOrg(org), appDB, agency, naics) 93 if err != nil { 94 t.Fatalf("vendor co occurrence field re run: %v", err) 95 } 96 first, _ := json.Marshal(rows) 97 second, _ := json.Marshal(again) 98 if string(first) != string(second) { 99 t.Errorf("the co occurrence field must be byte stable on a re run.\nfirst: %s\nsecond: %s", first, second) 100 } 101} 102 103// TestG2PartnerOrCompetitorRatio proves the team versus compete ratio is computed from PUBLIC co occurrence 104// alone (the is_galapagos self tag), never a tenant table. It seeds a partner that co occurs with the tenant's 105// own past performance in one market (a team market) and holds the prime alone in a second market in the same 106// core NAICS (a compete market), and proves the ratio is a meaningful decimal. It also seeds a second partner 107// with ONLY a team market (no compete market) and proves the ratio divides safely to a null pointer (the 108// divide by zero guard), never an error. 109func TestG2PartnerOrCompetitorRatio(t *testing.T) { 110 org := seedOrg(t) 111 run := uuid.NewString()[:8] 112 naics := "541330" 113 recent := time.Now().UTC().AddDate(0, -3, 0) 114 115 agencyTeam := "DEPT OF DEFENSE " + run // a market where the partner co occurs with the tenant 116 agencyCompete := "DEPT OF THE ARMY " + run // a market where the partner holds the prime alone 117 118 // The partner UEI must be unique per run: usaspending_awards is a global table on the shared staging DB 119 // and rows persist across runs, so a fixed UEI accumulates extra markets from prior runs (the agencies are 120 // already run suffixed). A unique partner isolates its segments so the exact market counts hold. 121 partner := "UEIP" + run 122 // Team market: the partner and the tenant's own is_galapagos award both in (agencyTeam, naics). 123 seedMarketAward(t, "G2-PR-T1-"+run, "PIID-T1", agencyTeam, naics, partner, "Partner AA LLC", "5000000.00", recent, false) 124 seedMarketAward(t, "G2-PR-T2-"+run, "PIID-T2", agencyTeam, naics, "UEIGALAPAGOS3", "Galapagos Federal", "1000000.00", recent, true) 125 // Compete market: the partner holds the prime alone in (agencyCompete, naics), no tenant award present. 126 seedMarketAward(t, "G2-PR-C1-"+run, "PIID-C1", agencyCompete, naics, partner, "Partner AA LLC", "4000000.00", recent, false) 127 128 rows, err := ai.PartnerOrCompetitorRatio(ctxOrg(org), appDB, partner, naics) 129 if err != nil { 130 t.Fatalf("partner or competitor ratio: %v", err) 131 } 132 if len(rows) != 1 { 133 t.Fatalf("the ratio must return a single summary row, got %d", len(rows)) 134 } 135 r := rows[0] 136 if r.PartnerUEI != partner { 137 t.Errorf("the summary must name the partner UEI, got %q", r.PartnerUEI) 138 } 139 if r.PartnerRole != "prime-of-record" { 140 t.Errorf("the partner must be labeled prime-of-record, got %q", r.PartnerRole) 141 } 142 if r.TeamMarkets != 1 { 143 t.Errorf("the partner must have exactly 1 team market (co occurring with the tenant), got %d", r.TeamMarkets) 144 } 145 if r.CompeteMarkets != 1 { 146 t.Errorf("the partner must have exactly 1 compete market (prime alone), got %d", r.CompeteMarkets) 147 } 148 // The ratio is team over compete, 1 over 1 equals 1, an exact decimal, never a float. 149 if r.TeamVsCompeteRatio == nil || !r.TeamVsCompeteRatio.Equal(decimal.NewFromInt(1)) { 150 t.Errorf("the team versus compete ratio must be the decimal 1, got %v", r.TeamVsCompeteRatio) 151 } 152 153 // The divide by zero safe case: a partner with ONLY a team market and no compete market. The ratio divides 154 // to a null decimal pointer (the NULLIF guard), never a divide by zero error. 155 partnerTeamOnly := "UEIB" + run 156 seedMarketAward(t, "G2-PR-TO1-"+run, "PIID-TO1", agencyTeam, naics, partnerTeamOnly, "Partner BB LLC", "3000000.00", recent, false) 157 // (the tenant's own is_galapagos award is already present in agencyTeam from above, so this is a team market) 158 159 zeroRows, err := ai.PartnerOrCompetitorRatio(ctxOrg(org), appDB, partnerTeamOnly, naics) 160 if err != nil { 161 t.Fatalf("partner or competitor ratio (team only): %v", err) 162 } 163 if len(zeroRows) != 1 { 164 t.Fatalf("the team only ratio must return a single summary row, got %d", len(zeroRows)) 165 } 166 z := zeroRows[0] 167 if z.TeamMarkets != 1 { 168 t.Errorf("the team only partner must have 1 team market, got %d", z.TeamMarkets) 169 } 170 if z.CompeteMarkets != 0 { 171 t.Errorf("the team only partner must have 0 compete markets, got %d", z.CompeteMarkets) 172 } 173 if z.TeamVsCompeteRatio != nil { 174 t.Errorf("a partner with no compete market must divide to a null ratio (the divide by zero guard), got %v", z.TeamVsCompeteRatio) 175 } 176} 177 178// TestG2RecompeteTeamingField proves the recompete teaming field returns the expiring opportunities in the 179// forward window, each carrying its incumbent UEI labeled prime-of-record joined to that incumbent's co 180// occurring vendor neighborhood in the same NAICS over the public awards, the likely teaming field before the 181// RFP drops, ordered by the period of performance end with a unique tiebreaker, and byte stable on a re run. 182// It includes a NULL slice case: an expiring opportunity whose incumbent has NO co occurring neighborhood, so 183// the LEFT JOIN yields a null neighbor that must scan cleanly (the empty string neighbor UEI and a nil 184// neighbor dollars), never a failed scan. 185func TestG2RecompeteTeamingField(t *testing.T) { 186 org := seedOrg(t) 187 run := uuid.NewString()[:8] 188 agency := "DEPT OF THE NAVY " + run 189 naics := "541512" 190 recent := time.Now().UTC().AddDate(0, -3, 0) 191 soon := time.Now().UTC().AddDate(0, 6, 0) // pop end six months out, inside the default window 192 193 incumbent := "UEIINCUMBENT01" 194 neighbor := "UEINEIGHBOR002" 195 galapagosNbr := "UEIGALAPAGOS3" 196 197 // The incumbent and two neighbors all hold awards in the SAME (agency, naics), so the neighbors co occur 198 // with the incumbent. One neighbor is the tenant's own past performance (is_galapagos). 199 seedMarketAward(t, "G2-RT-INC-"+run, "PIID-INC", agency, naics, incumbent, "Incumbent Prime LLC", "9000000.00", recent, false) 200 seedMarketAward(t, "G2-RT-NBR-"+run, "PIID-NBR", agency, naics, neighbor, "Neighbor LLC", "2000000.00", recent, false) 201 seedMarketAward(t, "G2-RT-GAL-"+run, "PIID-GAL", agency, naics, galapagosNbr, "Galapagos Federal", "1000000.00", recent, true) 202 203 // The expiring opportunity whose incumbent has a real co occurring neighborhood. 204 seedTeamingOpportunity(t, "G2-RT-OPP-"+run, agency, naics, incumbent, "Incumbent Prime LLC", soon) 205 206 // The NULL slice case: an expiring opportunity in a DIFFERENT NAICS whose incumbent holds no award in that 207 // NAICS, so it has no co occurring neighborhood. The LEFT JOIN must yield a null neighbor that scans cleanly. 208 lonelyNaics := "999999" 209 seedTeamingOpportunity(t, "G2-RT-LONELY-"+run, agency, lonelyNaics, "UEILONELYINC9", "Lonely Inc LLC", soon) 210 211 rows, err := ai.RecompeteTeamingField(ctxOrg(org), appDB, agency, 0) 212 if err != nil { 213 t.Fatalf("recompete teaming field: %v", err) 214 } 215 if len(rows) == 0 { 216 t.Fatal("the teaming field must return the expiring opportunities and their incumbent neighborhoods") 217 } 218 219 var sawNeighbor, sawGalapagosNbr, sawLonely bool 220 prevDate := "" 221 for _, r := range rows { 222 // Ordered by the period of performance end ascending (the byte stable order); the dates are non 223 // decreasing. 224 if prevDate != "" && r.PopEndDate < prevDate { 225 t.Errorf("the teaming field must be ordered by the period of performance end ascending, got %s after %s", r.PopEndDate, prevDate) 226 } 227 prevDate = r.PopEndDate 228 229 if r.IncumbentRole != "prime-of-record" { 230 t.Errorf("the incumbent must be labeled prime-of-record, got %q for %s", r.IncumbentRole, r.OpportunityID) 231 } 232 if r.IncumbentUEI == "" { 233 t.Errorf("every expiring opportunity in the field must carry its incumbent UEI, got empty for %s", r.OpportunityID) 234 } 235 236 switch r.IncumbentUEI { 237 case incumbent: 238 // The real neighborhood: the neighbor and the galapagos neighbor co occur with the incumbent, the 239 // incumbent's own UEI is excluded from its neighborhood. 240 if r.NeighborUEI == incumbent { 241 t.Error("the incumbent must be excluded from its own neighborhood") 242 } 243 if r.NeighborUEI == neighbor { 244 sawNeighbor = true 245 if r.NeighborDollars == nil || r.NeighborDollars.LessThanOrEqual(decimal.Zero) { 246 t.Errorf("a co occurring neighbor must carry positive segment dollars as a decimal, got %v", r.NeighborDollars) 247 } 248 } 249 if r.NeighborUEI == galapagosNbr { 250 sawGalapagosNbr = true 251 if !r.NeighborIsGalapagos { 252 t.Error("the tenant's own past performance neighbor must be flagged is_galapagos") 253 } 254 } 255 case "UEILONELYINC9": 256 // The NULL slice case: the lonely incumbent has no neighborhood, so the LEFT JOIN yields a null 257 // neighbor that scans cleanly (the empty string neighbor UEI, a nil neighbor dollars, a zero edge 258 // count), never a failed scan. 259 sawLonely = true 260 if r.NeighborUEI != "" { 261 t.Errorf("the lonely incumbent must have an empty neighbor UEI, got %q", r.NeighborUEI) 262 } 263 if r.NeighborDollars != nil { 264 t.Errorf("the lonely incumbent must have a nil neighbor dollars, got %v", r.NeighborDollars) 265 } 266 if r.NeighborEdgeCount != 0 { 267 t.Errorf("the lonely incumbent must have a zero neighbor edge count, got %d", r.NeighborEdgeCount) 268 } 269 } 270 } 271 if !sawNeighbor { 272 t.Error("the teaming field must include the co occurring neighbor of the incumbent") 273 } 274 if !sawGalapagosNbr { 275 t.Error("the teaming field must include the tenant's own past performance neighbor flagged is_galapagos") 276 } 277 if !sawLonely { 278 t.Error("the teaming field must include the lonely incumbent and scan its null neighborhood cleanly (the NULL slice case)") 279 } 280 281 again, err := ai.RecompeteTeamingField(ctxOrg(org), appDB, agency, 0) 282 if err != nil { 283 t.Fatalf("recompete teaming field re run: %v", err) 284 } 285 first, _ := json.Marshal(rows) 286 second, _ := json.Marshal(again) 287 if string(first) != string(second) { 288 t.Errorf("the recompete teaming field must be byte stable on a re run.\nfirst: %s\nsecond: %s", first, second) 289 } 290} 291