Janady13/missionmatch / internal/modules/federalsignal/service_test.go

1package federalsignal 2 3import ( 4 "context" 5 "sort" 6 "testing" 7 8 "github.com/missionworkforce/missionmatch/internal/platform/audit" 9 "github.com/missionworkforce/missionmatch/internal/platform/database/dbgen" 10) 11 12// fakeRepo is an in memory Repo: it serves fixture rows and records every upsert so the test can assert 13// the exact tags and incumbent roles the service wrote. It honors idempotency the way the real ON 14// CONFLICT DO UPDATE does, keying mission tags on (record_table, record_id, mission_code) and incumbent 15// roles on (record_table, record_id, labor_category), so a second run never grows the row set. 16type fakeRepo struct { 17 aliasPairs map[string]string 18 opps []dbgen.ListOpportunityRecordsForClassifyRow 19 awards []dbgen.ListAwardsForClassifyRow 20 sam []dbgen.ListSamForClassifyRow 21 22 missionTags map[string]dbgen.UpsertFederalMissionTagParams 23 incumbentRoles map[string]dbgen.UpsertAwardIncumbentRoleParams 24} 25 26func newFakeRepo() *fakeRepo { 27 return &fakeRepo{ 28 missionTags: map[string]dbgen.UpsertFederalMissionTagParams{}, 29 incumbentRoles: map[string]dbgen.UpsertAwardIncumbentRoleParams{}, 30 } 31} 32 33func (r *fakeRepo) AliasPairs(_ context.Context) (map[string]string, error) { return r.aliasPairs, nil } 34 35func (r *fakeRepo) ListOpportunityRecordsForClassify(_ context.Context) ([]dbgen.ListOpportunityRecordsForClassifyRow, error) { 36 return r.opps, nil 37} 38 39func (r *fakeRepo) ListAwardsForClassify(_ context.Context) ([]dbgen.ListAwardsForClassifyRow, error) { 40 return r.awards, nil 41} 42 43func (r *fakeRepo) ListSamForClassify(_ context.Context) ([]dbgen.ListSamForClassifyRow, error) { 44 return r.sam, nil 45} 46 47func (r *fakeRepo) UpsertFederalMissionTag(_ context.Context, p dbgen.UpsertFederalMissionTagParams) error { 48 r.missionTags[p.RecordTable+"|"+p.RecordID+"|"+p.MissionCode] = p 49 return nil 50} 51 52func (r *fakeRepo) UpsertAwardIncumbentRole(_ context.Context, p dbgen.UpsertAwardIncumbentRoleParams) error { 53 r.incumbentRoles[p.RecordTable+"|"+p.RecordID+"|"+p.LaborCategory] = p 54 return nil 55} 56 57// fakeFetcher returns fixed attachment text per description URL, no network. A miss returns empty text. 58type fakeFetcher struct{ byURL map[string]string } 59 60func (f *fakeFetcher) FetchSolicitationText(_ context.Context, descURL string, _ []string) (string, error) { 61 return f.byURL[descURL], nil 62} 63 64// fakeAuditor records the events the service emits so the test can assert exactly one, with the counts 65// only action and no PII or record text in the body. 66type fakeAuditor struct{ events []audit.Event } 67 68func (a *fakeAuditor) System(_ context.Context, e audit.Event) error { 69 a.events = append(a.events, e) 70 return nil 71} 72 73// fixtureRepo builds the spec fixtures: one opportunity titled "SIGINT collection support", one award 74// described "3 ISSO and 2 Cyber Engineer", and one sam notice whose fetcher returns 75// "SIGINT Analyst x2 and ISSO". The alias index maps a curated phrase to COMSEC so the alias mechanism is 76// exercised alongside the keyword mechanism. 77func fixtureRepo() *fakeRepo { 78 r := newFakeRepo() 79 r.aliasPairs = map[string]string{ 80 "comsec custodian": "COMSEC", 81 } 82 r.opps = []dbgen.ListOpportunityRecordsForClassifyRow{ 83 {RecordID: "opp-1", Title: "SIGINT collection support", Psc: "", Naics: ""}, 84 } 85 r.awards = []dbgen.ListAwardsForClassifyRow{ 86 {RecordID: "award-1", Description: "3 ISSO and 2 Cyber Engineer", NaicsDescription: "", NaicsCode: ""}, 87 } 88 r.sam = []dbgen.ListSamForClassifyRow{ 89 {RecordID: "sam-1", DescriptionUrl: "https://api.sam.gov/desc/sam-1", ResourceLinks: []byte(`[]`)}, 90 } 91 return r 92} 93 94func fixtureFetcher() *fakeFetcher { 95 return &fakeFetcher{byURL: map[string]string{ 96 "https://api.sam.gov/desc/sam-1": "SIGINT Analyst x2 and ISSO", 97 }} 98} 99 100// TestClassifyAllWritesExactTagsAndRoles asserts the service writes exactly the expected mission tags and 101// incumbent roles from the fixture records, with the right codes, mechanisms, evidence, and counts. 102func TestClassifyAllWritesExactTagsAndRoles(t *testing.T) { 103 repo := fixtureRepo() 104 aud := &fakeAuditor{} 105 svc := NewService(repo, fixtureFetcher(), aud, 50) 106 107 res, err := svc.ClassifyAll(context.Background()) 108 if err != nil { 109 t.Fatalf("ClassifyAll: %v", err) 110 } 111 112 // Mission tags. The opportunity title yields a SIGINT keyword hit. The award has no mission bearing 113 // text, so it produces no mission tag. SAM notices are never mission tagged here (the 0026 CHECK 114 // forbids it), so the only mission tag is the opportunity SIGINT one. 115 wantTags := map[string]dbgen.UpsertFederalMissionTagParams{ 116 "opportunity_records|opp-1|SIGINT": { 117 RecordTable: "opportunity_records", RecordID: "opp-1", MissionCode: "SIGINT", 118 Mechanism: "keyword", Evidence: "sigint", Confidence: confidenceFull, 119 }, 120 } 121 if len(repo.missionTags) != len(wantTags) { 122 t.Fatalf("mission tags = %v, want %v", keysOf(repo.missionTags), keysOf(wantTags)) 123 } 124 for k, want := range wantTags { 125 got, ok := repo.missionTags[k] 126 if !ok { 127 t.Fatalf("missing mission tag %q", k) 128 } 129 if got.MissionCode != want.MissionCode || got.Mechanism != want.Mechanism || got.Evidence != want.Evidence || !got.Confidence.Equal(want.Confidence) { 130 t.Fatalf("mission tag %q = %+v, want %+v", k, got, want) 131 } 132 } 133 134 // Incumbent roles. The award description "3 ISSO and 2 Cyber Engineer" yields ISSO (one "isso" match) 135 // and Cyber Engineer (one "cyber engineer" match). The SAM attachment text "SIGINT Analyst x2 and 136 // ISSO" yields ISSO (one match) and Intelligence Analyst (one "sigint" match). Counts are the literal 137 // occurrence totals, never fabricated. 138 wantRoles := map[string]dbgen.UpsertAwardIncumbentRoleParams{ 139 "usaspending_awards|award-1|ISSO": {RecordTable: "usaspending_awards", RecordID: "award-1", LaborCategory: "ISSO", RoleCount: 1, Evidence: "isso"}, 140 "usaspending_awards|award-1|Cyber Engineer": {RecordTable: "usaspending_awards", RecordID: "award-1", LaborCategory: "Cyber Engineer", RoleCount: 1, Evidence: "cyber engineer"}, 141 "sam_opportunities|sam-1|ISSO": {RecordTable: "sam_opportunities", RecordID: "sam-1", LaborCategory: "ISSO", RoleCount: 1, Evidence: "isso"}, 142 "sam_opportunities|sam-1|Intelligence Analyst": {RecordTable: "sam_opportunities", RecordID: "sam-1", LaborCategory: "Intelligence Analyst", RoleCount: 1, Evidence: "sigint"}, 143 } 144 if len(repo.incumbentRoles) != len(wantRoles) { 145 t.Fatalf("incumbent roles = %v, want %v", keysOf(repo.incumbentRoles), keysOf(wantRoles)) 146 } 147 for k, want := range wantRoles { 148 got, ok := repo.incumbentRoles[k] 149 if !ok { 150 t.Fatalf("missing incumbent role %q", k) 151 } 152 if got != want { 153 t.Fatalf("incumbent role %q = %+v, want %+v", k, got, want) 154 } 155 } 156 157 // Result counts reflect what was actually written. 158 if res.RecordsScanned != 3 { 159 t.Fatalf("RecordsScanned = %d, want 3", res.RecordsScanned) 160 } 161 if res.MissionTagsWritten != 1 { 162 t.Fatalf("MissionTagsWritten = %d, want 1", res.MissionTagsWritten) 163 } 164 if res.IncumbentRoles != 4 { 165 t.Fatalf("IncumbentRoles = %d, want 4", res.IncumbentRoles) 166 } 167 if res.SamFetched != 1 || res.SamSkippedCap != 0 { 168 t.Fatalf("SamFetched=%d SamSkippedCap=%d, want 1 and 0", res.SamFetched, res.SamSkippedCap) 169 } 170 171 // Exactly one audit event, counts only action, no PII in the action or entity fields. 172 if len(aud.events) != 1 { 173 t.Fatalf("audit events = %d, want 1", len(aud.events)) 174 } 175 if aud.events[0].Action != "aedt.federalsignal.classified" { 176 t.Fatalf("audit action = %q", aud.events[0].Action) 177 } 178} 179 180// TestClassifyAllAliasMechanism proves a curated alias phrase tags a mission with the alias mechanism, 181// separate from the keyword path. The alias phrase "spectrum operations" carries no mission keyword of 182// its own (EW's keyword form is "electronic warfare"), so only the alias layer can produce the tag, 183// proving the alias mechanism is genuinely exercised and not shadowed by a keyword. 184func TestClassifyAllAliasMechanism(t *testing.T) { 185 repo := newFakeRepo() 186 repo.aliasPairs = map[string]string{"spectrum operations": "EW"} 187 repo.opps = []dbgen.ListOpportunityRecordsForClassifyRow{ 188 {RecordID: "opp-alias", Title: "seeking Spectrum Operations support for the program", Psc: "", Naics: ""}, 189 } 190 svc := NewService(repo, fixtureFetcher(), &fakeAuditor{}, 50) 191 if _, err := svc.ClassifyAll(context.Background()); err != nil { 192 t.Fatalf("ClassifyAll: %v", err) 193 } 194 got, ok := repo.missionTags["opportunity_records|opp-alias|EW"] 195 if !ok { 196 t.Fatalf("missing EW alias tag, have %v", keysOf(repo.missionTags)) 197 } 198 if got.Mechanism != "alias" || got.Evidence != "spectrum operations" { 199 t.Fatalf("alias tag = %+v, want alias mechanism with evidence spectrum operations", got) 200 } 201} 202 203// TestClassifyAllIsIdempotent runs the pass twice over the same fixtures and asserts the second run wrote 204// the exact same row set (no duplicates, no growth), the AEDT reproducibility mandate for a repeatable 205// sync. 206func TestClassifyAllIsIdempotent(t *testing.T) { 207 repo := fixtureRepo() 208 svc := NewService(repo, fixtureFetcher(), &fakeAuditor{}, 50) 209 210 r1, err := svc.ClassifyAll(context.Background()) 211 if err != nil { 212 t.Fatalf("first run: %v", err) 213 } 214 tagsAfterFirst := keysOf(repo.missionTags) 215 rolesAfterFirst := keysOf(repo.incumbentRoles) 216 217 r2, err := svc.ClassifyAll(context.Background()) 218 if err != nil { 219 t.Fatalf("second run: %v", err) 220 } 221 222 if !equalStrings(tagsAfterFirst, keysOf(repo.missionTags)) { 223 t.Fatalf("mission tags grew on rerun: %v then %v", tagsAfterFirst, keysOf(repo.missionTags)) 224 } 225 if !equalStrings(rolesAfterFirst, keysOf(repo.incumbentRoles)) { 226 t.Fatalf("incumbent roles grew on rerun: %v then %v", rolesAfterFirst, keysOf(repo.incumbentRoles)) 227 } 228 if r1 != r2 { 229 t.Fatalf("result not deterministic across runs: %+v then %+v", r1, r2) 230 } 231} 232 233// TestClassifyAllAttachmentCap proves the max attachments bound skips SAM notices past the cap and counts 234// them as skipped, never silently dropping them, and that mission tags and award roles are unaffected. 235func TestClassifyAllAttachmentCap(t *testing.T) { 236 repo := fixtureRepo() 237 repo.sam = []dbgen.ListSamForClassifyRow{ 238 {RecordID: "sam-1", DescriptionUrl: "https://api.sam.gov/desc/sam-1", ResourceLinks: []byte(`[]`)}, 239 {RecordID: "sam-2", DescriptionUrl: "https://api.sam.gov/desc/sam-2", ResourceLinks: []byte(`[]`)}, 240 } 241 fetch := &fakeFetcher{byURL: map[string]string{ 242 "https://api.sam.gov/desc/sam-1": "ISSO", 243 "https://api.sam.gov/desc/sam-2": "ISSO", 244 }} 245 svc := NewService(repo, fetch, &fakeAuditor{}, 1) // cap at one SAM notice 246 247 res, err := svc.ClassifyAll(context.Background()) 248 if err != nil { 249 t.Fatalf("ClassifyAll: %v", err) 250 } 251 if res.SamFetched != 1 || res.SamSkippedCap != 1 { 252 t.Fatalf("SamFetched=%d SamSkippedCap=%d, want 1 and 1", res.SamFetched, res.SamSkippedCap) 253 } 254 if _, ok := repo.incumbentRoles["sam_opportunities|sam-2|ISSO"]; ok { 255 t.Fatalf("sam-2 was over the cap and must not have been mined") 256 } 257} 258 259func keysOf[V any](m map[string]V) []string { 260 out := make([]string, 0, len(m)) 261 for k := range m { 262 out = append(out, k) 263 } 264 sort.Strings(out) 265 return out 266} 267 268func equalStrings(a, b []string) bool { 269 if len(a) != len(b) { 270 return false 271 } 272 for i := range a { 273 if a[i] != b[i] { 274 return false 275 } 276 } 277 return true 278} 279